{
 "cells": [
  {
   "cell_type": "markdown",
   "source": [
    "# 准备数据"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "outputs": [],
   "source": [
    "from sklearn import datasets\n",
    "import numpy as np\n",
    "import os\n",
    "import cv2\n",
    "from sklearn.model_selection import train_test_split\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "\"\"\"\n",
    "https://zhuanlan.zhihu.com/p/264578345\n",
    "代码链接\n",
    "\"\"\"\n",
    "\n",
    "\n",
    "def get_two_data():\n",
    "    X = [[1, 2],\n",
    "         [2, 3],\n",
    "         [3, 3],\n",
    "         [4, 5],\n",
    "         [5, 5],\n",
    "         [1, 0],\n",
    "         [2, 1],\n",
    "         [3, 1],\n",
    "         [3, 2],\n",
    "         [5, 3],\n",
    "         [6, 5]]\n",
    "    Y = [0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1]\n",
    "    return X, Y\n",
    "\n",
    "\n",
    "def get_image_data():\n",
    "    \"\"\"\n",
    "    准备数据\n",
    "    :return:\n",
    "    \"\"\"\n",
    "    image = []\n",
    "    y = []\n",
    "\n",
    "    data_path = r\"att_faces\"\n",
    "    root_path = os.listdir(data_path)\n",
    "    for idx, d in enumerate(root_path):\n",
    "        s_path = os.path.join(data_path, d)\n",
    "        for image_path in os.listdir(s_path):\n",
    "            # 因为是二维图,所以是二维的 [112,92]\n",
    "            img = cv2.imread(os.path.join(s_path, image_path), cv2.IMREAD_GRAYSCALE)\n",
    "            # image.append(img.flatten())\n",
    "            # 取前K个特征\n",
    "            u, sigma, v = np.linalg.svd(img)\n",
    "            sigma = np.sort(sigma)\n",
    "            # 选取特征值K个最大特征值作为Sm_i的特征值\n",
    "            image.append(sigma[-100:])\n",
    "            y.append(idx)\n",
    "    return image, y\n",
    "\n",
    "\n",
    "def get_iris_data():\n",
    "    iris = datasets.load_iris()\n",
    "    X = iris.data\n",
    "    # 燕尾花数据集\n",
    "    # X 为[150,4] 4 个特征分3类\n",
    "    Y = iris.target\n",
    "\n",
    "    return X, Y"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "# LDA核心思路"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "\n",
    "def calculate_covariance_matrix(x, y=np.empty((0, 0))):\n",
    "    \"\"\"\n",
    "    计算矩阵X的协方差矩阵\n",
    "    :param x:\n",
    "    :param y:\n",
    "    :return:\n",
    "    \"\"\"\n",
    "    if not y.any():\n",
    "        y = x\n",
    "    # n_samples 样本的个数\n",
    "    n_samples = np.shape(x)[0]\n",
    "    covariance_matrix = (1 / (n_samples - 1)) * (x - x.mean(axis=0)).T.dot(y - y.mean(axis=0))\n",
    "    return np.array(covariance_matrix, dtype=float)\n",
    "\n",
    "\n",
    "# 所有样本的均值\n",
    "mu = []\n",
    "# 每个类的均值\n",
    "mui = []\n",
    "# 每个类的占样本的比例\n",
    "prior = {}\n",
    "K = 80\n",
    "labels = []\n",
    "# s_w矩阵\n",
    "s_w = \"\"\n",
    "\n",
    "\n",
    "def two(x, y):\n",
    "    \"\"\"\n",
    "    二分类\n",
    "    :param x:\n",
    "    :param y:\n",
    "    :return:\n",
    "    \"\"\"\n",
    "    global mu, mui, prior, labels, s_w\n",
    "\n",
    "    # X.shape[0] 表示数据的个数，X.shape[1] 表示数据的特征数,\n",
    "    # 以 燕尾花就是有4个特征,n_samples=3 ,n_features=4\n",
    "    n_features = x.shape[1]\n",
    "    n_samples = x.shape[0]  # 表示样本是数量\n",
    "    labels = np.unique(y)  # labels =3表示有3类\n",
    "\n",
    "    SW = np.zeros((n_features, n_features))\n",
    "    SB = np.zeros((n_features, n_features))\n",
    "\n",
    "    for label in labels:\n",
    "        # 获取同一类的样本数据\n",
    "        x_i = x[y == label]\n",
    "        mu_i = x_i.mean(axis=0)  # 计算同一类的均值\n",
    "        SW = SW + (x_i.shape[0] - 1) * calculate_covariance_matrix(x_i)\n",
    "\n",
    "        mui.append(mu_i)\n",
    "        prior[label] = len(x[y == label]) / n_samples  # 计算先验概率\n",
    "\n",
    "    s_w = SW\n",
    "    m = mui[0] - mui[1]\n",
    "    m = m[:, None]  # 转成列向量\n",
    "    SB = m @ m.T\n",
    "    Sw_inv = np.linalg.inv(SW)\n",
    "    return np.dot(Sw_inv, m)\n",
    "\n",
    "\n",
    "def multiclass(x, y):\n",
    "    \"\"\"\n",
    "    多分类\n",
    "    :param x:\n",
    "    :param y:\n",
    "    :return:\n",
    "    \"\"\"\n",
    "    global mu, mui, prior, labels, s_w\n",
    "    # X.shape[0] 表示数据的个数，X.shape[1] 表示数据的特征数,\n",
    "\n",
    "    n_features = x.shape[1]  # n_features=4 燕尾花就是有4个特征\n",
    "    n_samples = x.shape[0]  # 表示样本是数量\n",
    "    labels = np.unique(y)  # labels =3表示有3类\n",
    "    # 对每一行求均值,mu\n",
    "    mu = x.mean(axis=0)\n",
    "    SW = np.zeros((n_features, n_features))\n",
    "    SB = np.zeros((n_features, n_features))\n",
    "    for label in labels:\n",
    "        x_i = x[y == label]\n",
    "        mu_i = x_i.mean(axis=0)  # 计算同一类的均值\n",
    "        m = mu_i - mu\n",
    "        m = m[:, None]  # 转换成列向量\n",
    "        SB = SB + x_i.shape[0] * m.dot(m.T)  # 计算类间散度矩阵S_b\n",
    "        SW = SW + (x_i.shape[0] - 1) * calculate_covariance_matrix(x_i)  # 计算类内散度矩阵S_w\n",
    "        mui.append(mu_i)\n",
    "        prior[label] = len(x[y == label]) / n_samples  # 计算先验概率\n",
    "\n",
    "    s_w = SW\n",
    "    # Calculate SW^-1 * SB by SVD (pseudoinverse of diagonal matrix S)\n",
    "    # 使用svd 来计算 sw的逆\n",
    "    # U, S, V = np.linalg.svd(SW)\n",
    "    # S = np.diag(S)\n",
    "    # # 求出sw的逆矩阵\n",
    "    # SW_inverse = V.dot(np.linalg.pinv(S)).dot(U.T)\n",
    "    # A = SW_inverse.dot(SB)\n",
    "    Sw_inv = np.linalg.inv(SW)\n",
    "    A = Sw_inv.dot(SB)\n",
    "    # 获取特征值和特征向量\n",
    "    eigen_values, eigen_vectors = np.linalg.eig(A)\n",
    "    # 将特征值按照其绝对值从大到小进行排序(因为SW, SB是对称阵, 故A也是对称阵,\n",
    "    # 因此A的特征值是非负的), 取其前k个特征值以及对应的k个特征向量\n",
    "    idx = eigen_values.argsort()[::-1]\n",
    "    w = eigen_vectors[:, idx]\n",
    "    return w\n",
    "\n",
    "\n",
    "def predict(X_train, X_test, y_train, y_test, W):\n",
    "    \"\"\"\n",
    "    对测试的数据进行预测\n",
    "    :param self:\n",
    "    :param x:\n",
    "    :return:\n",
    "    \"\"\"\n",
    "    # 将的维数\n",
    "    acc = 0\n",
    "\n",
    "    transform = (X_train - mu) @ W\n",
    "    transform_test = (X_test - mu) @ W\n",
    "    y_predict = []\n",
    "    for idx, test in enumerate(transform_test):\n",
    "        temp = []\n",
    "        for t in transform:\n",
    "            temp.append(np.linalg.norm(t - test))\n",
    "        index = y_train[np.argmin(temp)]\n",
    "        if index == y_test[idx]:\n",
    "            print(\"预测正确，图片为第{}类\".format(index))\n",
    "            acc += 1\n",
    "        else:\n",
    "            pass\n",
    "            print(\"预测错误，预测为第{}类,因为是第{}类\".format(index, y_test[idx]))\n",
    "        y_predict.append(index)\n",
    "\n",
    "    print(\"准确率为{}%--[{}/{}]\".format(acc / len(y_predict) * 100, acc, len(y_predict)))\n",
    "\n",
    "\n",
    "def get_w(x, y):\n",
    "    \"\"\"\n",
    "    获取降维后x\n",
    "    :param x:\n",
    "    :param y:\n",
    "    :param k:\n",
    "    :return:\n",
    "    \"\"\"\n",
    "    x = np.asarray(x)\n",
    "    y = np.asarray(y)\n",
    "    ls = np.unique(y)\n",
    "    # 如果是二分类\n",
    "    if len(ls) == 2:\n",
    "        return two(x, y)\n",
    "    else:\n",
    "        return multiclass(x, y)\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 绘制图片"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "outputs": [],
   "source": [
    "def face_recognition():\n",
    "    \"\"\"\n",
    "    进行人脸识别\n",
    "    :return:\n",
    "    \"\"\"\n",
    "    X, Y = get_image_data()\n",
    "    X_train, X_test, y_train, y_test = train_test_split(X, Y, test_size=0.2, random_state=123)\n",
    "    W = get_w(X_train, y_train)[:, :27]\n",
    "    predict(X_train, X_test, y_train, y_test, W)\n",
    "\n",
    "\n",
    "def draw_two():\n",
    "    \"\"\"\n",
    "    进行二分类\n",
    "    :return:\n",
    "    \"\"\"\n",
    "    X, Y = get_two_data()\n",
    "    W = get_w(X, Y)[:, :1]\n",
    "    colors = ['red', 'green', 'blue']\n",
    "    fig, ax = plt.subplots(figsize=(10, 8))\n",
    "    print(zip(X, Y))\n",
    "    for point, pred in zip(X, Y):\n",
    "        # 画出原始数据的散点图\n",
    "        ax.scatter(point[0], point[1], color=colors[pred], alpha=0.5)\n",
    "        # 每个数据点在W上的投影\n",
    "        proj = (np.dot(point, W) * W) / np.dot(W.T, W)\n",
    "        # 画出所有数据的投影\n",
    "        ax.scatter(proj[0], proj[1], color=colors[pred], alpha=0.5)\n",
    "    plt.show()\n",
    "\n",
    "\n",
    "def draw_iris():\n",
    "    \"\"\"\n",
    "    测试燕尾花 数据集\n",
    "    :return:\n",
    "    \"\"\"\n",
    "    X, y = get_iris_data()\n",
    "    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=123)\n",
    "    W = get_w(X_train, y_train)[:, :2]\n",
    "    predict(X_train, X_test, y_train, y_test, W)\n",
    "\n",
    "    ax1 = plt.subplot(2, 1, 1)\n",
    "    # 第一行第二列图形\n",
    "    ax2 = plt.subplot(2, 1, 2)\n",
    "    plt.rcParams['font.sans-serif'] = ['simHei']\n",
    "    plt.rcParams['axes.unicode_minus'] = False\n",
    "    # 将数据投影到这两个特征向量上，从而达到降维的目的\n",
    "    transformed = X @ W\n",
    "    plt.sca(ax1)\n",
    "    plt.scatter(transformed[:, 0], transformed[:, 1], c=y, cmap=plt.cm.Set1)\n",
    "    plt.title('自己预测的')\n",
    "    from sklearn.discriminant_analysis import LinearDiscriminantAnalysis\n",
    "    sk_lda = LinearDiscriminantAnalysis()\n",
    "    sk_lda.fit(X, y)\n",
    "    transformed = sk_lda.transform(X)\n",
    "    plt.sca(ax2)\n",
    "    plt.scatter(transformed[:, 0], transformed[:, 1], c=y, cmap=plt.cm.Set1)\n",
    "    plt.title(\"官方库预测的\")\n",
    "    plt.show()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 绘制二分类"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<zip object at 0x000001BE2D4C8F80>\n"
     ]
    },
    {
     "data": {
      "text/plain": "<Figure size 720x576 with 1 Axes>",
      "image/png": "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\n"
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "draw_two()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 绘制3分类"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "预测正确，图片为第1类\n",
      "预测正确，图片为第2类\n",
      "预测正确，图片为第2类\n",
      "预测正确，图片为第1类\n",
      "预测正确，图片为第0类\n",
      "预测正确，图片为第2类\n",
      "预测正确，图片为第1类\n",
      "预测正确，图片为第0类\n",
      "预测正确，图片为第0类\n",
      "预测正确，图片为第1类\n",
      "预测正确，图片为第2类\n",
      "预测正确，图片为第0类\n",
      "预测正确，图片为第1类\n",
      "预测正确，图片为第2类\n",
      "预测正确，图片为第2类\n",
      "预测正确，图片为第2类\n",
      "预测正确，图片为第0类\n",
      "预测正确，图片为第0类\n",
      "预测正确，图片为第1类\n",
      "预测正确，图片为第0类\n",
      "预测正确，图片为第0类\n",
      "预测错误，预测为第1类,因为是第2类\n",
      "预测正确，图片为第0类\n",
      "预测正确，图片为第2类\n",
      "预测正确，图片为第0类\n",
      "预测正确，图片为第0类\n",
      "预测正确，图片为第0类\n",
      "预测正确，图片为第2类\n",
      "预测正确，图片为第2类\n",
      "预测正确，图片为第0类\n",
      "准确率为96.66666666666667%--[29/30]\n"
     ]
    },
    {
     "data": {
      "text/plain": "<Figure size 432x288 with 2 Axes>",
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXoAAAEGCAYAAABrQF4qAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAAB2uElEQVR4nO2dd5gb1dWH3zujsr163Xvvaxv3hrENGLBNx/QUEkhCSCGk50soIQkJEBICJJQk1NBdAGNjMMW997bufe3tXat2vz9GK6uMdqUt3uL7Po8er2bu3DkaS2funHvu7wgpJQqFQqFou2jNbYBCoVAomhbl6BUKhaKNoxy9QqFQtHGUo1coFIo2jnL0CoVC0cZRjl6haAaEEMJkm6U5bFG0fZSjV7RqhBDDhBD/qqONRQhha8A5bEII3WSb8P09JYo+fhXiyMcLIZaFNPtSCDGqvnYqFJFQIwhFa2cIkFBHm+8DvxZCOIHQhSN24KSUcgSAEKIzsBgoBZKBcuBL4GIhRDfACZzyHXezEOKUr+9KYAnwLaDSZ9MrwLO+c94H/DHgvMOAVTVvhBBpQDtgS/QfXaGIDqEWTClaI0KI08AZIA4QQFXA7ixgmpRyfxT9TAMek1KOC9iWCnQBXgLul1Ku8W1/GvhYSrk4pA8NuAQYhHFjeB+4DuiI4dCfA96UUnb1tf8AGOOzuQT4PZCCcSMo83XbUUqZFN3VUChqR4VuFK0WKeUIKeVAKeUA398jfCPzw4A3lq5C3ncFVgIfSSnXCCFGCCFWAzcBjwghVgohngIQQnQELpNSfhZw/C4g1fe3C3CH9N8HGCil7AV8iPHk8DVgqpSyr5SyL8ZNTKFoFFToRtFaiRdCbIywbwDgqU+nvjj6PuAajFAKgA04BMzEuAlowGM1dgB/FkL0DOjGgRH6iY9wmtCb0MWAlFLuq6WNQlFvlKNXtFbKpZSjzXYIIVaGvL8UY+ScZ9LcDhwLeD8deBgjdFMmhHjB9x5gMPAo8EN8TwFSysNCiBm+9pN97TyEPyXUxnrgRSHES1LKu3zblKNXNBoqdKO4EKgG1kgpu4a+gOEYzhsAKeUnUsrxwOvAr4CDwGbf7kSMkX0QUso84DIgCWO+oIbaBlIrhBBb8U3eSilXAkOEEJfX90MqFJFQI3pFayWpjtBNIBFHx1LK0xiTp5H2jxVC1EzUDsFw/BDw2xFCTADuBO4F+gIngU3AAZ8tVpOup0gpi4UQvw/Y9gRwpxDiS4xJXYWiUVCOXtFaiTp0UxdCiDjgZeB7UsoCkyZngA+AecB/MbJlXgrY/xPgESnll0KIucBO4LfALRhx+rCngAjMBxYBaRgxfoWiUVCOXtFaSaljRB8YQpFAmhBCk1Kaje7nAJcSPIqO41wc/ogQ4mKMtM1yDId8K/jj/9nATUKIARiZOUOBfwAPSyl/5WsXOKq3YoRuPBgpmP/n2+7F+E3OwngaUCgaBeXoFa0VZx0jenvApoMYzvW0z7m6fS/d93IA35FSVvuOn48Rgnnct5DpBV9/c6WURUKIrwMLhBBXAWeBX0opvUKIZ4GfSSlLhBA/AB7y5djvAHYH2PMX4FUpZbUQIptzawA6AM8AazGeEhSKRkEtmFIo6kAIMUhKuSdkW5ZvEjZwm1VK6TI5PkFKWdnUdioUkVCOXqFQKNo4Kr1SoVAo2jjK0SsUCkUbp8VMxrZr10727Nmzuc1QKBSKVsWmTZvypZRZtbVpMY6+Z8+ebNwYKVtOoWjDeNyw9T+w/lkjKXTUt2HMdyG8NolCEYYQ4mhdbVqMo1coLkg8bnh+NJzZdm7b4nth/dPw3e2gmy2qVShiQ8XoFYrmZNdbwU6+hvy9xghfoWgElKNXKJqTzS9F3rfxn+fPDkWbRjl6haI5sSdH3qfCNopGQjl6haI5mfTzyPsm3H/+7FC0aZSjVyiak+4TYdwPw7f3ngnZd55/exRtEpV1o1A0N1c8BeN/BKufAE81jLoLuo6r6yiFImqUo1coWgLpPeGqp5vbCkUbRTl6hULR5BQWFrJlyxby8/PJzMxk5MiRZGZmNrdZFwzK0bdBPGfOUPne+3jz8rFPmYx92sUITU3HKJqH3NxcFi9ejNvtBqCkpIRjx45x5ZVX0rFjx2a27sJAOfo2huOrFRR+8y6k1wvV1VS8/jrW7OG0e/01hM3W3OYpzifOCig9ASldwZbYbGasXr3a7+RrcLvdfPnll/Tt2xer1Urv3r1JSkpqJgvbPsrRtyGk203h9+5FVlWd21ZRgWvLVireepukO25vRusuUA59Bmv/BpX5MPAaQ8Omttz5xsDrhU9/Aev/AZoOXg+MvRdmPgbN8GRXUGBWhtcY2W/atAlN09iwYQMXX3wxffv2Pc/WXRio5/k2hGvHDnA5w7bLqioq3323GSy6wFn1OPxvLuR8ACfWwBcPwr8uguryOg9t2Hn/DBueAXcVOMuNfzc8a2xvBmx1PEl6vV48Hg9ffvklTmf491fRcJSjb0tYrb5y1uEIq1pl2eSc3gIf3ANvXmvo1Cz/DbgCKgi6q4xQyuYXm9aONU8EnxeM92ueaNrzRmDo0KFYLHUHDzRN48SJE+fBogsPFbppQ1gHD0YkJyMrKoK2i4QEEm+9tZmsukDY8h9Y/H1wO0B64cAS8IaVjzWc/b5FMOFHxvsT62Dry8ZxQ26Cvpc3XJ64qjC27ZFwVkLeLkjsAGnd623OyJEjqaqqYt++fWiahstlcl18CCXN3CQoR9+GEJpG5n//Tf5NN4PHg3S5QNeJu2IW8ddc3dzmtV2cFYaTDxq9OyI0FpDkyzT58vew8o/nbg673oaBV8N1rzXM2bcfCme2h2/PGhJ9H2ueguW/Bs0CHid0nQA3vQsJGTGbo2kakydPZsyYMZSVlVFRUcFnn30WNkErpaRr164x96+oG+Xo2xi2YcPouHkjjqVL8RYWYR8/HuvgQc1tVtvmxFrDIUaDxQ6j74HiY7Di0eAbgqsC9i6EI19Cr2mx2+FxGZO+lz0Bb14NriqMWJ4Aazxc8bfo+slZHB52OrYK3pkHX1sWu10+7HY7drudzMxMBg0axO7du5FS+kfxM2bMwKpCjE2CcvRtEC0+noRrrmluMy4cnBXhMfEabMkgPeCuNv6VEt6YY2TgeExCGK5K2Ds/NkcvJaz8E6z4I3jdxk0n+04oOQZnd0H7ITDtQegyJrr+Vv/FuOkE4nXC8ZVQegpSOkdvmwlCCCZMmMDAgQM5fvw4FouFXr16ER8f36B+FZFRjl6haAhlp2HBNwwHG4o1Aea9D5/90pioBUPLxlMNO94wHL8ZthjTL9f/A776ffDNZtPzMPRW+NHh2MNA5bnm2zUrVOY12NHXkJ6eTnp6eqP0pagdlXWjUDSE1U+As8x83/gfQ2Y/OLsz3KlHcvJIGHRdbDas+EP4E4X0wo7X4KPvxdYXQJ/LDKduRruBsfenaHaUo1coGsKRz82za2xJ0O9KKD8DegwrkoUOqd1is6HibOR9W/8LRYdj62/yLyAuDbQAu60JRvhn0/Pw+YNw5CsjZKRoFcQcuhFCdADelVJOqaWNBTjkewHcJ6XcUT8TFYpm5vQWY7FR/j7oNgkm/fRcumFab19YJsTped2Q0gUS2pmHddB8x4Qcl97LOCYWkrtB6VHzfZoFjq82+o26v05GYfLVj8PBTwwJhd4z4fPfGk8Kboexr9d0uHm+sfq2mfF6vRw+fJhTp06RlJRE//79SUxsPtmHlkZMjl4IkQ68DNR1BYcD/5NS1lI+R6FoBexfAm9ffy4F8uxO2P4qfHs9tOsPkx6AA4uDQye6DbpNhrQexvtLHjGcZM0Ep2Y14vBCA1e50bdmNY67+t+xxdT3LoKKCDF1ICidMxaSO8Lljxt/e9zweIfgCVpXBRxebsw1ZN8Re/+NiMvlYtGiRZSUlOB2u9E0jS1btnDFFVfQqVOnZrWtpRBr6MYDzANK62g3HpgthFgvhHjJN8JXKFoXUsKH9xhOXHqNbV6XEZP/7JfG+67j4JqXISELrImg26HvLJgXIDkx8X648S3oOQ0yB8CY78G9O+G+vTD1/4z2w26FITfC2qdg47+MxUrRsORHxuSuGUIzQjA9p9Xr4/s5tSFChlCFERpqZnbu3ElxcbE/L9/r9eJ2u/nss8+QKrwE1DGiF0L8CxgQsGm5lPLhKFavbQBmSilPCyFeAa4EFjXIUoXifFNZYJ6BIr1w5Itz74fcAIOuheKjEJ9uvELpf5XxCmXqr4y89XduNBYmed1wYKkxyXv3BohLDT/m6ApDRsFZDsW1xN+zBsPNCxohtFLb7735V7IeOHAAjyd8ctvpdFJcXKwye6jD0Usp76lnv9ullDXDjI1AP7NGQoi7gbsBunev/xLrloz0eCj7xz8of+ElZEkJ1sGDSH3kYexjxza3aYq6sCUS0ZHFh6wQ1XTI6B37ObweWPC14NCPq8LIgV/zJFzyUHD7Lx4y5gv8i6EikNgRvtdI02JdxoAlLjy7yJpolD1sZnTd/EYmpYy470KjqbJuXhVCZAshdOAaYJtZIynl81LK0VLK0VlZWU1kSvNS8tDDlD39DLKoCLxeXDt3UXDr7Th37gpqJx0OqpYsoeLttyl7/nlyJ0/h1ICB5N04D+c208unaGqs8TB0nuHkgrYnwIT7G+cceXvM5RI81bA7RHG05ISxKMpVSa1O3poAlzzYOPaBcRO7eb6RSWRNNCZ4rQnQfzYMmdd456kngwYNMhVNS0lJISUlpRksank0OHYuhBgM3Cql/E3A5oeBNzCGQ4uklJ829DytEW9pKRWvvQ7VwTFU6XBQ9re/kfnC8wA4N28h//bbweNFVldDgOiTc/Vq8q+/kayFC7AOGXxe7VcAVz0LVcVw6BMj/u6uhtHfMV6NgS3JGNWb7gtZOHX4M2PS1iwmLyxgsRnpmVN+BRfd3Tj21dB9Etx/wrj5VBYYGTddRjfuOerJgAEDOHnyJEePGplHmqZhsVi49NJLm9mylkO9HL2UclrA37uB34Ts34mReXNB4z58JMhp+5ES1+49xp8uFwV3fg1ZEnl+WzoclD7+BJn/eamJLFVExJYIty40RtMlx4wFQ/UQ9vKTvw+2vWrE1wfMhV6XQNYgyN16bsIXjJHzuPtCbEk2z8gRFhj7fWPS1+OEz34Fj3c0nP6Qm+Di3zbMZh9eWzKM+AZaCytLqWkaM2fOpLCwkNzcXBISEujevXuD7HS73Rw7doyqqio6d+7c6uP8KhumCXAfPkzlwkVUb9xoVPsxQVZVUfb8C1i6dzdUJmtDSlw7dzaBpYqIFBwwlCVPrDOc+5RfQveJDetzy3/go3uNzB2v25hQ7T8bbnoPXpkBFXlGO68LRnzNyMQJpN8VmM4ZCA0u+rahfrnsZ8E3jA3PQM6HRrzeWj8tmaqqKlauXMmRI0cA6NSpE1OnTq09LOJ2GiGf85BjX1ZWxvr16zlx4gQWi4UhQ4Y0aM4vPz+fjz76CK/Xi9f3++3Tpw8XX3xxq5VRFi0l/Wj06NFy48aNzW1Ggyl/9TVKHnwI3G7jVQsiPh50HaQM05APxTZxAlnvvN2YpioicWYnvDTBmPCUHvzqj/PeN/Ti60NVETzROTweb02EG982UiyPrTSyfLqOD9Z/LzhgTMCe3mQIqBXsC+5Ds8IVf4elPzaP91sT4apnjJtHjHi9Xt555x3Kysr8Tk8Igd1u5+abbw6vHnVmByz6NvLUBvKsvajuOYv2s3+HPaVp5uCqqqp45513cDjOfW6LxULPnj2ZPn16zP1JKXnjjTeoCPk9WiwWpk6d2iJLHQohNkkpa42jqRF9I+LJy6Pkdw+GxeQjEVjbtTZEfBwpP/pR/Q1TxMYnDxihFT/SmAD96HvwgwP104o/9KlPPybEEbsqYOeb0P9K6Dk1/LjTW+A/U8HlABlh4OB1GWUK3RG+d64KIyWzHo7+5MmTVFZW+p08GM7Q7XZz4MABBg8OmDcqPwP/nkyp28birIeo1FIQpRLvm+8wZtwkhmdnx3z+uti9e3dYIRO3283hw4cpKysjOTk2gbiCggLTcoZut5s9e/Y0uqP3er2UlJRgt9tJSEho1L4DUY6+EXF89hlC12vLh4gNXUdr357Uhx/CPqmBYQNF9Bxfbb695BhUl0FcPTI5dBvmqZoiPKsnkI9/FHLTiYCjiIiZOJrVEFerByUlJUFOvga3201RUVHwxo3PIz1OFmc+QKnezggp1ezauIF2WVl07tw4ypc15ObmmubQa5pGQUFBzI7e7LNGs68+HDp0iBUrVuDxeJBS0r59e2bOnNkkcs0ta1allSN0S2QnH2tBhfh4Un/7f3TcsI6EK69oqGmKWEjINN+uWeod56b3pZg6Yms8jPh65ONOrImu/9QeRojGDM0C/WZH108IGRkZpnFpi8VCu3YhmjxntlMgsqjUUoOcPIDb42VnI88zeTye8JuNDyllvVIr27VrZzqJa7FY6NevfjdLM/Lz8/niiy+orq7G7Xbj8XjIzc1lyZIljXaOQJSjb0TiZs4wn3yNiyP1oQexjomy8AOA242Ij2+1kz+tmgk/MfLEA7HEw4hvgF7PCki2BCMX3Zroy0dPMEbyE38GnUfDzrfgk5/C2r/DumfgxYnwiN1cGTMUS7wRo+85zfg7FKHB8xfBe7dFDu9EoFOnTqSlpQU5v5oYfZ8+fYIbdxlLtSUdgfnINzCO3hjs27eP6ghh0oyMDDIy6lf2cPr06VgsFv9nrrmpDRgwoI6jo2f79u2mpRSLiooi3rwaggrdNCJaejrpT/2Voh/9GCEE0uf0k39wH0lfuxO9a1cKv/6NiJk4Qbhc2Ea3jDzlC46x9xphmvVPGyEXd7VREWrWXxvWb+8Z8MBp+OpRQxit/AxsfA7W/tVIi3RHN2eDsBg3HHcVZPQ1Sgf2m2XoyO//CHa/bxT1Pr3FiOvXiJHtmW+s6L3y6ahNFkIwe/Zs1q1bx4EDB5BS0qNHDyZMmBC+SOmib5G1+im8JtJWNVWkGpP9+/ebhm2EEIyJZVAVQrdu3bjpppvYv38/lZWVdO3alW7dujVqWml5uXk4TtM0KioqGj2dUzn6RiZhzmzsEyfg+HgJ0ukkbuYMLL5UL/u4sWCzQTQjG13H8emnWAf0b2KLFWEIAZf9Gab+Ggr2Q2p3SGrfOH2f2gjr/n7OqVecif5YSwLghYHXwjX/NUIygc5H02DAHEjqBC+MJSxU5K6CzS/BrKdiSnu02WxMmTKFKVMiKpMbxKdj+/YqJiz6K2sd/XBj9U9cezye8AydAAJrx0ZLJMer6zp2uz2mvkJJSkpi5MiRDeqjNrp06UJeXl7Yjcrj8YSHxBoB5eibAD0zk8Tbbwva5j58mJJH/whI48tfV1qrx4Nz2/amM1JRN3Gpjb/687NfRz9yD6XbBLjuVSP8U3bK0IkPjb56vfDmNUScmPU4jRRMWxNptaf3ZPDX/kbhypXs2bPHrx4ppWTVqlXY7XZ69uzpM9XL5s2b2blzJ06nk8zMTCZNmkTHjtHJKg8aNIi8vLywEEhNAfKWzJAhQ9izZw8Oh8M/yWuxWBg6dChxcbVMztcT5eibiOo1a6h4621wOrFPnULJ7x4ycuVrHLym1RnCcSxZQsnvHyXl179Ssfq2Qv6e+h97fBUsfQD2vGeMyHUbXP4kjPwGVJcblaYq86G6JHIf6b2azsn7kFL6wzyBuN1uNmzY4Hf0q1atYv/+/X5HXVBQwOLFi7n66qujctR9+vThxIkTHDx4EDBG+EIILr/88hb/e4mLi+P6669ny5YtHDt2jLi4OIYNG0bv3vUQxosC5ejriZQS56bNOJYuRcTFEX/NNVj7GP9JJX96jPIXXvSHaKoWfRA+gvd6DWdvsYBJ3i4AHg8VL7+Cbdw44i+d2ZQfR3G+yOhrhG/qg8cNe941RuUefLn99xr6M4eXG5IHYK4dD8ak7FXP1u/cMeByucJy22soKzMUMB0OBzk5OWGhC7fbzebNm+nTpw+HDh3CarUyYMAA01G+EIJp06YxfPhwTp8+TVxcHD169DAVOGuJxMfHM3HiRCZObPrU6dZxRVoYUkqKf/4Lqt6fj3Q4QNcpe/Y5kn/8Y2R5GeXPPBs8Wo8QphGJiVj69Ma1Zy94PKYraWVlJRUvv6IcfVth+qNGaKU+4RvpNhx8IO4qOLAkWPbADKEZtWD7NL3Ql9VqxW63m2bZpKYa+vrl5eVommY6mXrkyBGOHDnifyI4ePAgI0eOjBgzr2+GzYWEcvT1wLl2LVXzF5xb2eqTOyj74x8NSYMoF1bI6moynn0GPF6qliyh9KmnoCK8spAsKws/WNE66XsZXP+GURmqJKDOa81oPKMvlJ4ILtt3rhGmsfdonHzn0UZx7yZCSsnx48fJyclBSknv3r3Zt29fkCPXdZ1x48YBkJycHHEBklnIZ/PmzQwYMICEhAT/cU0hrlbzJGKNdd1LC0c5+npQueiDyPIFJiOUSFgHD8LSw6grmvTNb1D21N/Cf8bxccRfPbd+hipaJoOuMV6OUkPJcu2TRnUqCNexAbAmGQurnBXgjrLEYCDSC2d3Q/GReq+QrYuVK1cGxdstFguZmZlUVlZSWVlJamoq48ePp2vXroAxYTpgwABycnLCJlPN0DSNw4cPc/r0af9ov0OHDkydOpW0tLQG219WVsYXX3zBmTNGFlRWVhaXXHJJm9GzVwum6oGwWuundxJCxn//c67PuDjSnvgLIi7OeCoAREIC1n79SLzl5gafS9ECiUuBzL5GPr30+ATUQhAa9JgCPzkJl/4pZCFXDN9BdxWsfKzBJptRWFgY5rDdbjeFhYXMmDGDb33rW9x4441069Yt6LiJEyeSnZ0dVSqklJJt27Zx5MgRvF4vUkpyc3NZsGBBxEVT0eLxeFi4cCG5ubl+xcozZ86wYMGCqG5CrQHl6OtB3MwZDXf0djuenP1BmxLmzCFryWISv/F14ufOIe2PfyBr4QJD5VLR8qkuM0bo6542KkdFw5b/RAjT+JBeI8SjWw19+uteh85jILmzUUx85mPhq3hN+/HA6c3R2RQjx48fNy3C7Xa7OX78eNj2U6dOsXTpUhYuXIjH4yE7O5sOHTrUeZ7AVMQaPB4POTk59TceOHz4MC6XyzRkdOjQoQb13VJQoZsYkdXVFP/051HH4SMhrFa8ZeHFRqz9+pH20IMN6lvRDBxdCa9fCUhDax5haNhc9UzkQUF1WXCR8UgkBmSc1IR9pIQdbxg3lfhMIze+rlh9/j54ZggktINR3zb07hshzm2z2dA0LcwJ67oetkhq9+7drF271j9SzsvLi+ocQ4YMYdeuXWHbPR4PhYWF9bTcoKyszHTk7na7/VlCrR3l6GOk6uOP8RYV1b3gKRCTnHnpcmH3TUwpWjkeF7x5dXjx7G2vQL8rYUAEQbEF34Cqgrr7101WlC7+AWwNfBqI4gnTXQl5u42/T22CnI/gxv+FtzvyFWx72fhcw24xtPJDblbl5eUcPHgQj8dDp06dIp4yUNbX7XYHOflY6N69u6mjNxVXi5HMzEwsFktYSqjVam3xC6+iRTn6WpAOBxVvvU3VokWIxCSSvnYnrt176iwSEoTNhqVPH9xHj0JlJQiBiIsj+acPoLXy8mQKH8dW+UbxIbgqYMtL5o6+qtio/GR2XCh5IaqPJcdhy4shRUZiFMd2VUDOIji1GTqPOrd92S9h/d+NoitI2PO+ofNz3at+Z79v3z5WrlyJlBIpJZqm0b17d06cOHHOGimZPn16kMZ6fn5+vRcytW/fnszMTPLz8/2ZPEIIrFZrg1Ulu3XrRnJyMsXFxUEZPUlJSQ2qVNWSUI7eBE9BAbKigsLvfA9XTg74Mmyca1YjsmKolGO1EnfJJWT881mqFi6i8oMP0dLSSLzjduxjlGBZm6E2hclIi5ccRcbq1miStJJ8oRtXlbHy9dgqn9iaiWaS0Ax1TI+77gwdrxuOfnnO0RccgHV/C87xd1XA3gXGOXtMxuFwsHLlyqC0SY/Hw/Hjx5k1a5ZfW71z585hC5dqW0hVG3Fxcei6zpVXXsmGDRvIycnB6/XSvXt3xo8fHxYeklLicrmwWq1R3ViEEMydO5eNGzdy4MABwFh1O2bMmBZXH7e+KEcfgPvkKYq+9z2c23cYoRaPJyhEIyurkEePRe5A1xGJicjqarTMTJK+dRdJd30T1549VLz6Gs4tWxCJiegdO2DLHo6oReQpFM+ZM7iPHMHSqxd6+0YS2FI0Dt2nmIfyrImQfYf5MandjUlUVx3O2JpgyCYvvs8QJBPCcOZmNxDNAsPvgP5XGfr0b8yuXTRNtxnx+hoOLsX0ycBVCfs+gB6TOXbsmKnzrKnqNGnSJNNTVVRU8Nlnn9X+WU0QQjBr1izACKXUtZJ07969bNiwAYfDgdVqZcSIEWRnZ9fp8G0223lbpdocKEfvQ3o85F93PZ7Tp2PKhQ9E2O1kLXgfa4ButfvIEfKvv9Ef7pFlZZS/9G88J06Q8ewzuI8do/L9+ciSEuJmzMA2aWLQl1K6XBTd/xOqPlqMsNmQTifxs68i/YnHjTRPRfNjjYPrXoN3bzayWzxOw8n3mg6DbzA/RtPhyn/Awm+ec/Zazf+nMPr0uuHi3xrFRzb/O2Q1rc/hB07A6jaY/HNo5/v+Tf0NfPrzyDcToRtKmP7PkWhIIIeiW8Fedz554Oi3oqKCTZs2cfz4cWw2G4mJiRFH80IIdF9KcXJyMp06daKwsJCMjAxGjx4dtcjXgQMHWL16tX8OwOl0snnzZoQQZDdBGcPWhHL0PqpXrDAmWevp5BECLSsLS/9zssLS66X4dw8iK0N+aA4HVUuWUv7fVyh95BGkxwMuFxWvvY794ovJeP6fCN+PpvTxJ6ha/DFUVyN9+cJVHy1G79yZ1F/8vH62KhqfgXPhvn2w7TVwFELfK6DXJbWn4Q6dByndjPz24sPQ82KY9HPjJlB22nDYQofHMkwkEyToPgeo6UYRk2v+e87Jg6Gr76mGr35vlCP0eoybgW4FWwrcsgDsSQGf4RpYfG+4nUKH4bcCxqSoWSqlxWLxFyJxOBy89957VFdXI6WkoqIiYjENq9XK2LFjsVgspKam0qFDh5jj+F6vl4KCAtavXx820et2u9myZQvDhw9v8UJnTUlMjl4IkQq8CehABTBPSmmqyCWEeAkYDHwkpfx9Qw1tajynTtc/ZVIIsFiw9OpJ9YqVxE2dgnS5KLjza1SvXGX+WG+zUvLQQ0GCZrKykuovv8SxdCnxVxjlAytefiVcv97hoOLlV5Sjb2mkdoOpv4ztmO4T4daF4duTfZkseXsNZ22GNQHu3mhk+2QNDteYFwIm/gTG/wgcJUbsPnerEeLpOCI8tTI+DebNh7evx5/F43XDnOcN1UuMePnFF1/MF198AeCfjB02bBjtfSHFnTt3mualm+H1eunatatfAydWjh8/zvLly/F6vRGfGFwuFx6Pp9WInTUFsX7y24AnpZTLhBDPAbOARaGNhBDXAbqUcoIQ4t9CiH5Syv2h7VoSttoe7SwWU8ExP5oGLhfVX3yJc/16Eu+6C0uPHlRv3Bj55lHlQNjtyBDlSllZSeX7C/yOXkaoRBNpu6KNsejbkfPjO4+B9J5196HpkOAT/eo6tva2fS+DB87AoU+NSebeMw1dfh8Oh4MdO3b4R8dSSrp27cpFF13kb3Pq1ClTsbJQdF2nU6dO9Xby5eXlLFu2rM50TavVypo1a9B1nX79+pEVS0JFGyEmRy+lDNQ4zQLORmg6DXjb9/cnwGSgRTt665DB2KZMxrliZbiOTV15vwFfallZRfnzL2AdPAgqI+jh2GzYRo3EtTM8LxhA2M7F3q3Z2bi2bg239wKPOV4Q5O+D3AirWTULzPxD05zXlmCEogLwer1s376dTZs2hTnxkydPsnPnToYPHw4YCpVnzpwJG9Hruk5iYiJlZWVomkafPn38k7dFRUV+qeHu3btHNfret29fRGG0GoQQuN1u9uzZgxCCvXv3kp2dHXRjuhCo9WoKIf4FBFbEXS6lfFgIMQFIl1KujXBoInDS93chMMqskRDibuBuoEXkq2Y+/y/KX/o3Ff/+D56TJ+s+IAJC15HlkXPt4+fMIe3RR8gdOz782IQEEubN879Pe/QR8m+cZ8TnPR4js8duJ+3RR+ptn6KVUHIsYII2hPZDoVPTlboLZfny5Rw9etR0pO52u9m9e7ff0Q8bNoyDBw8GjbQ1TSMzM5NrrrkGl8uFrutomoaUki+//NKf1lhTPGT27Nl1LoSqqKiI6Og1TSMhIYHKykp/GyklbrebrVu30q9fvzYjWBYNtSaJSinvkVJOC3g9LITIAJ4GvlnLoeVAjUBLUqTzSCmfl1KOllKObgmPU8JqJfk79xA3c2bDtGw0DfslFyMSwjVItPbtSX/qSbTkZDJfehGRmIhITIS4OIizk3DH7dinTPa3t40YQdaSj0mYdxPW4cNJmHcT7ZcuqT3UpGgbdMg2j8/rdugfYbVtE1BSUhLRydfgDAhBZmRkMHPmTBISErBYLGiaRpcuXYLSJGsydA4dOuRfYevxeHC5XDidTpYuXVpnjL9r166mI39d17nhhhvo27dvxBuBmQZPWybWyVgb8A7wSynl0VqabsII16wFsgET7dWWhXPbNirfehtvVRWeI0djkzgIRddI+elP8RYUUvXRYvB6jVRITSPzPy/5M2rsEyfQcfNGHEs/wVtWRtzFU7H06hXWnbVPb9L/8uf626NonSS1h4vugc0vnEuRFDrYk2HsfeHt83Ng5/+MhVQDr607Hh8lBQUFEYuEgBEeCX0i7969O7fddhvl5eVYrVbi4uIoLy9n1apVnD59muTkZLKzs9mzZ49pjL26uppt27ZRUlJCQkICAwYMCBuB9+zZk/T0dIqKioLkkfv06UNaWpr/qcHM2dekc14oiGhmxv2Nhfgu8Adgm2/Tc8AO4FYp5W8C2qUAK4DPgCuA8VLKWgpZwujRo+XGjfUssdZAyp59jrInn0RWO43JU5vNiMvXIwtHZGTQ7tWXsY0YAYBr126q16xBS08n7opZaCajfIUiIlIaC6XW/hWqiqDv5XDJw0aGTyAb/glL7zcmUL0eQ79+xNeNXP0GphWePXuWDz/8MOKkZ3x8PNdddx2JiZFr0ZaVlfHee+/hdruDimEnJCRQWhou7ieE8N9cNE1D0zRmzpwZdkOpib8fOHAAXdcZPHgwffr0QQhBSUkJ77zzjqmjv/3224PkGVozQohNUspal9rH5OhjPHk6cCnwlZQyt672zeXoPbm55E6cDKGa1jWpZ9E4eyHAaiXp+/eS8sMfIC7gNC5FM1B+Bp7qGS6JYE2AOz6B7uarVaNFSsn7779PUVFRkNMUQjB8+HCys7PrXNT0xRdfsH///rBwjMViQUoZVZaOzWbjzjvvjFqWwOv18tJLL5mGgCZMmMCwYcOi6qelE42jbzIhByllkZTy7WicfHPi+GoFwuwxzuvFOmY0lv79EbVN2mga8bOvIuv9d0n9yf3KySvOP/sXm69odVXBrrfDt8eIEIKrrrqKrl27+kfXqampzJkzh3HjxkW1cvXkyZMRY+4ZGRn+WHttTlxKSX5+ftR2nzhxIuI5t23bZrq9rXLBeyUtPt780VbXsWdnk/q73wJweuRFeM+aZJNqGim/+DmWnj1jOq/rwAHK/v4PXDt3YB0wgOT77jNSMhWKWNEs5irFQphLHEdLdZmRT48grs+lzJo1y7/4KFpZghri4+OpMFF9lVIya9Yszp49y4kTJ4iPj+f48eP+kn6hbWOJrZfXstbE6TRd59lmueAdvX3GdNPtwmol4aYb/e/1Lp3NHb3NZoiN+Ry9rKrCW1yM1r69+ZMCxsRv/g03+VMm3fsP4Fj2KZmvvYJ9fHjKpUJRK/1nwwf3hG/X7UZxkfqw+z2Yf6dxEwEj7n/D/7AOmFOvwtnZ2dl8+eWXYSmXSUlJrFu3jk6dOjFu3Di/FEJBQUHYnEB8fDwZGRlRn7OmPq0ZbUVnPlrahgZnA9ASEsj8738QSYmIpCQj1dFuJ+X/foN10LkRtm38ePORf2UlWnoG0umk+Je/4tSQYeROnsrp7JFUvGX+2FxSo39TE5f0epFVVRT/+v8AY+RS/upr5E6awqkhQym469u4DraNkmaKJiA+Ha5/HSzxhjCZJd7Qvrn4/+qXa196Et6/w8j0qS41Xq4KeGceVERXESqU3r17M2LECHRd96dXer1eSktLycnJYdWqVX59nN69e9OvXz90Xcdisfizdi6//PKY9GpSUlJMSxQKIZg8ebLJEW2XJpuMjZWmnox1rFhJxWuvISsqiJ87l4Rrrg6SCZZVVTi+/BLpcGCfOhU9ZOTg2r+fs9NMRv9CkPituwzpgvfeD9KlEfHxZDz/L+KmXxJ0yMmevcFMl0MIOh89TMmjf6DylVfPrdDVNERiIu0/W4alS5f6XwRF68fjhnV/hw3PGs53wFyY9hAkd4TKAkM73u0wRvlpPep3jjV/hU9/GZ7Db02Ayx6HMd+tt/lOp5OioiKWLVtGZYjYX41mzjhf5bWSkhJOnz5NfHw8Xbt2rVdKpNvt5quvvuLgwYNIKUlISGDatGm1jvZbG9FMxl4QoZuSJ56k4p//RPokCarXrafyzbdo9/ab/slTER9PvG9Bhxne4hJDaz40zigl1StX4T50KCxzR1ZVUfrUU2GOXktJwVsQXkJOJCTgLSmh4r8vB/flG/GXP/scaY+2eH04RVMy/07Yt/BcXv2W/xiVqu7dDQmZMOquhp/DWWFeTMXjMlQwG4DNZiMhIYHq0Cw3jCyZQ4cO+R19amoqycnJCCHqrTxpsViYPn06F198MR6PJ+piJG2NNu/oPadPU/7MM1AdMPlSWYlrxw4cS5YSP/uqqPrRO3dCmuURC4HWsQPi6BHTYm6e4yfCtiV+6y7K/v60v3IVAHFxJH79a7gPHjJ050N/CG43zmZaZ6BoIRQcgL3zg9MovS5wFBsOf8KPGuc8fWfByj+G69hrFkN+2YTCwkJWr15Nbm4uVquVIUOGMGrUKNMsmtpG5jX78vPzWbFiBXl5eei6Tv/+/ZkwYUK9FSh1Xb/gFkkF0uZj9NVr1yIs4ZNHsrKSqqVLo+7H0qWLUcw7pCqUiIsj4frrkG6TPGAhsI0Kl/lJvvd7JN50I9jtiORksNuJnzuHlJ8+gKVLlzBFSwA0DUvv3lHbq2iDnN5srn3jqjRKAjYWXUbDsNuMeH8N1kQY9S3oMDSseXl5OQsXLuTUqVN4vV7/qtYaKeNQEhISyMzMDBtZWywWBg8eTFlZGYsWLSIvz5gP8Hg85OTk8MknnzTaR7zQaNUjeun1Ur1yFZ5jx7AOHYLVpGSYlpwSMX1Si2EGHyDj+X9S9OP7cXy2HKHriMQE4ubOpeSBn4XH3IVAxMeT8tOfhPUjdJ20PzxKyk8fwH30KHr37v45Ab1zJ+xTp1L91VdB4Rtht5P0vfrHRhVtgLQe5pLFug0y+4dvbwhz/gVDboRtrxqyC9l3GIVUTNi+fXvYgiePx8Phw4cpLy8nKSkp7JiZM2eyaNEif3ESKSXdu3dn8ODBrFu3Lmw1q8fj4fTp0xQXF5OWlhb1x8jNzfULpvXt25eOHTtGfWxbotU6ek9eHnnXXo/37Fmk14sArCNH0O7VVxABOb72qVMQVmt4WMVqJfHWW2I6p5acTOaLL+AtKcFbWopITeXMqNHI0MIggGXwYDL+9lesAwdG7i89HVt6etj2jOeeofiXv6JqoSH1r2dlkfanP2JrIyv5FPWky1jI6AN5u42CIDVoVhjdyIMAIaDPpcarDvLy8iLqyRQXF5s6+qSkJGbNmsXRo0exWCx07dqVdN9vobCwMGJ/JSUlUTv6tWvXsmvXLv9NKCcnh4EDB7bZurC10WpDN0U//gme48eNydGqKmRVFc5Nmyl96m9B7YTNRuabb6BlZRkplMnJiPh40v70x6DarrGgpaZi6dYN16ZNECHup3foEJSeGVP/8fFkPPVXOu/ZRcdNG+iwbk3YhK7iAkQIuPNT6DXTVxLQDul94fYl0RUgaSLMwjBgjMLNioo4HA4WLFjAggUL2Lp1K+vXr2f37t3+VaxZWVkR+0s3GRiZUVhYyI4dO4KeNGp0cQpMEiHaOq1yRO+tqqJ6xYrwgiDV1VS++VZYiT3b0KF03LQB58aNyKoqbGPGoNUiwBQtopbVgVpiwwWTRFwceowrEBVtnMQsuONjozSgqwqSOjRYtKyhDBs2jJycnKAFTrqu07VrV5KTk8Paf/755+Tn5weN2vft20dGRgaDBg2iS5cubDUpttOlS5cgBcvi4mJWrVrFqVOnsFgs9O/f37/oaseOHabyBx6Ph6NHj6oFU62CWio+yUiV5nUd+7hxxE2bVquTd588hXPbNryhBb1NsI0Zg7Dbw88VH0/CbbfVebxCUW/iUo3c+RaQKpiamhpUKETXdQYOHMiMGTPC2lZXV3Py5Mmw0Izb7WbHjh0ArFmzJuw4IUTQ00FlZSULFizwa+i4XC727t3LUl+CRc1ErhlmUgxtnVY5oteSk7EOHoxr+/bgHRYL8VfMwrVnD86t29A7dcQ+ZUpEKYJAvKWlFN79HarXrzdK+bk9JD/wE5K/Y7K03IewWMh87RXyb77VWOXq9SI9HhK//S3iplxYK+8UFzbt27fnuuuuw+v11pr37nK5Iu5zOp1UVVVRXFwctk9KyaFDh5gwYQIAu3fvNp0Azs3NpaCgoNYSg2arZds6rdLRA6T/9Qnyrr0O6XSBw4FISECkpuI5c5azs+caXyZdR0tNod3772GpYyVc4b3fp3rdOnA6/TnsZY8/gaV3L+Ivuyzicbbhw+m0ZZOxqrakFPukSeidOzXqZ1UoWgt1SQgnJiYSFxcXNqquKV5S22KmwH35+fmm0sZCCJYtWxZR0EwIQe8LME251Tp668CBdFi1isp33sZ94CC2UaPwFBVR/uRfweHwZ9l4qqoo/O73aP/Booh9efLzqV65CkLy143VqP+s1dGDkfpYVxuFQmE42kmTJvHpp5/6R92apmGz2bjooouIi4ujXbt2nA0RENR1nQEByRPt2rXjxIkTpiEgs0ImNeeePn16vRddtWZa9SfWM9JJvudcaOXM1Gnn9GFq8Hhw7dyFJy8PPUJdWm9hoZGCabJQyWOmWKlQKOqF2+1m48aNQaNzKSXjx4/3V6iaPn06CxcuxO12+ytMpaWl+YuPAwwePJidO3dGLTcshGDkyJH06dOncT9QK6F1TsZGQDpNCikDaFq4pEAAll69zlWUCtphwT51SiNZp1Aodu3aRUlJSVDYRUrJ6tWr/aPzlJQUbr31VsaNG0d8fDxer5eioiLefPNNf1HvhIQErr76ajp16uQvO1hb2MdiscS00Kqt0aYcffycOWESBQB6+/botag+CquV1IceRMTHn9totaIlJ5Pywx80hakKxQXJwYMHTWProdWjNE1j27ZtVFZW4vV68Xg8VFVVsWzZMkpKjPLT6enpzJkzh29961uMHTu2zvh+zxiLA7Ul2pSjT/7+vVi6dkXUFP212xGJiaQ//fc6FesS591E5qsvY58+HcvAASR+7U7af/oJeic1sapQNBaRipZIKYP25ebm4nA4wnLhvV4ve/bsCdomhKBTp04RJ4LtdjtXXXXVBRmbr6FNfXItNZX2y5ZS9cGHVK9di969O4k3z0OPMp3KPmECdl/6lkKhaHyGDBlCXl5eWPWoxMTEoNBKqFZ9DV6vl7KysrDtWVlZdOvWjePHj/v71nWdjIwMrr766qgLigdSWlrKhg0bOHXqFHa7nezsbPr3798qZY5jcvRCiFTgTUAHKoB5Usqw2RAhhAU45HsB3Cel3NFAW6OzMS6OhBtvIOHGG87H6RQKRQz06tWL3Nxc9uzZ43e+Vqs1rHpU+/btTXPhLRYLXSKEYWfMmMGBAwfYs2cPUkr69+/PwIED6+Xky8vLef/99/2TvVVVVaxatYqSkhLGjh0bc3/NTawj+tuAJ6WUy4QQzwGzALO8xeHA/6SUPzfZp1AoLlCEEEycOJHhw4eTm5tLfHy8adglOTmZfv36ceDAAf8IXdM0EhIS6N/fXKlT0zT69+8fcX8sbN++Peypo2b1bnZ2NnaTFfEtmZhudVLKZ6WUy3xvs4BIuYfjgdlCiPVCiJd8I3yFQqEADPXKvn370qVLl4gj7ilTppCdne2P3VutVoYOHRpzARGn00lxcXGY466N06dPmz5RaJpGUVFRTOdvCdTqgIUQ/wICJR6XSykfFkJMANKllGsjHLoBmCmlPC2EeAW4EpORvxDibuBugO7du9fHfoVC0UYpLi5m27ZtfgddXV3N+vXrcTqdjDIp6ON2uyksLCQuLo6UlBQ8Hg8rVqzg4MGDaJqGlJKRI0cyYsSIOuPsqamppiqXXq/XVHa5pVOro5dShgm9CCEygKeB62s5dLuUsiZxfSPQL0L/zwPPg1EcPBqDFQrFhcGmTZtMwydbt25l+PDhQVk0e/fu9Yuheb1eMjIySE9P96dz1qR0btmyhcTExDrDO9nZ2Rw7dizo/Jqm0blz51bp6GMK3QghbMA7wC+llEdrafqqECJbCKED1wDb6m+iQqG4EImkQCmECNKyOXPmDKtXr8blcuFyufB4POTl5ZGTkxOWs19zo6iLrKwspk+fTkJCArquo2kaPXv2ZObMmQ36TM1FrLHzu4BRwK+FEL8GngN2ALdKKX8T0O5h4A1AAIuklJ82hrEKheLCISUlxTSV0uv1kpBwrt7Djh07Yoq/V4XKpESgZ8+e9OjRg8rKSmw2W8Q1AK2BmBy9lPI5DOceym9C2u3EyLxpEbgOHqLqgw/A4yH+iiuwDq5f5SeFQnH+GDVqFGfOnAkraNK3b19sASvgY9WXb9++fdRthRB+DZ7WTJtaGWtG+Ysvcfayyyn761OU/e3v5M2ZS8kf/9TcZikUijro1KkT06ZNIyEhAU3T/AVNJk8OrvXQvXt300ycGg2cQCwWS6vMg28obTrt0X3yFCV/+CMECJpJj4eKl14ifs4cbEOHNKN1CoWiLnr37k2vXr1wOp1YLBZThz548GB2795NVVWVPyXSYrEQHx8fNtrPyMggIyPjvNjekmjTI3rHsmWmpdak00XV4sXNYJFCoYgVIQR2uz1i/rzdbuf6669nxIgRZGZm0qVLF0aNGhXk+GsoLCzk9OnT58PsFkWbHtELXUcIgVneZjTlBRUKResgLi6O0aNHM3r0aAA2b95sOkHrdrvJzc2lc+fO59vEZqVNj+jjLr8MKU1qR1qtxM+dc/4NUigU54WEhARTtUqLxRKUsXOh0KYdvd6+PWl/+hPY7RAXZ/xrt5Py0wew9jNdw6VQKNoAvXv3Nl39qmrGtlESb7yBuKlTqFqyFDwe4i67tM5C4QqFonVjs9mYPXs2y5Ytw+FwAEZ459JLLw1KzbxQEKHC/s3F6NGj5caNG5vbDIVC0YaQUvorUqWmprZKLfm6EEJsklKOrrVNS3H0Qog8oDZZhWhpB+TX2aptciF/driwP7/67BcuA6SUybU1aDGhGyllVmP0I4TYWNfdra1yIX92uLA/v/rsF+ZnB+Pz19WmTU/GKhQKhUI5eoVCoWjztEVH/3xzG9CMXMifHRr4+YUQmhCiT2MZU08bwmYLo6zQdiH/31/Inx2i+PxtztH7iplckLT1zy6EiBNCPCWEiDfbH/j5fU57Woyn6A+sEUJEpUcrhLD5ai6EbhO+v6dE0cevQhz5eCHEspBmXwohwksqBdDW/+9r40L+7BDd528xWTcKRTQIId7GqHHwWh3tkoADwFwp5foIba4Cfg04AzZnA/sAB0Y9hQTgx8AhYDFQCiQD5cCXwMVAN18fpwA7cLPv7w+ASmAJ8C3f3wnAK8CzgPS16yx9P0Rfec3OUsoHfe/TgHXAQKl+rIoQfBX/LgK2SCkjZh61KUcvhEgF3gR0oAKYJ6V01n5U20EI0QF4V0pZ50iyNSCEsGP8P26to+kIDAdK4P+3EOJW4IyU8rOAbRbAK6X0CiFuB0ZJKe/37RsBzJZS/j6CPalAF+Al4H4p5Rrf9qeBj6WUi0Paa8AlwCCMG8P7wHVAR2AYRm2HN6WUXX3tPwDGAFVACfB7IAX4I1BTgaOjlDKoll1b+3+PFvV7F+nAR77XzcB0KaVpWa4Wk17ZSNwGPCmlXCaEeA6YhUlR8raI7z/9ZaD1V0k4hxc4WudiECEOAu8ClwohyjEcZTpw0rc/sLmO4Wx3AB5A+kpkuoBrfees6VcDLAHOoyuwAuM7tsZ3Y3gW6ANMFEL8CtgopfyREKIjMEJKuUQIUVPpZhfwuO9vFxCqutUHY+ReLIT4PcaTw9eAqVLKfQGfNfCzt8X/92i5YH/vPoZjDDjW+r4Ho4ClZg3blKOXUj4b8DYLONtctjQDHmAesLC5DWkspJQuoI8QYiawACMUE0gv4EbgpxghmnghxL8xQipXSSlvquMUAsOxf+n7exiwQQhxiW+/DuwB7vY9CezDqIHczrffhhHSmYlxE9CAx3z74oE/CyF6BpzPgRH6MZ1jIOAm4+NiQNY4+Qht2tz/e7Rc4L93pJRfAgghpgJjMUq4mtKqHb0Q4l/AgIBNy6WUDwshJgDpUsq1zWRak1PLZ28uk5oSF4aT/1HI9t9jOLppwNu+bZ8AE4HLhRB7Q9ofkFLODngfD5RLKScIIZ4FngKOAJdKKR8JOXY6xg+pC1AmhHiBcz+swcCjwA8x4u5IKQ8LIWb42teURPLU7I+S9cCLQoiXpJR3+bYFOXopZSmEPbVcUFwIv/dI+Cb+5wFFGL8TU1q1o5dS3hO6zTc58TRw/fm36Pxh9tnbMF7AyrmRdA1PYYRDbsUXpgEKgR7A44HOWggxGXgo5Ph0oEAIcSfwTYxRUQqQIYS4GmOE/nsp5ftSyk+AT4QQfwLWAr8CNmPE1BMxRvZBSCnzhBDf8PUTWOqott/dCiGEByOO/wsp5UohxONCiMullKaP5RcyF8rvPRK+Cfp7hRCPAHOBt8zatWpHH4ov1voO8EspZWPo5ihaBhLoDvzCZN8p4DDnwiFJQD/giZB2HYHQ0kKdgC+AT4EFUspSX5jodinl132jJdMUZCnlWCHEON/bIUBN7Nz/m/KNNO8E7gX6YtyMNmE8nQzAuHmFMiUgRl/DE8CdQogvMSZ1FajfuxDi58BpKeUrQBpQHKltW8ujvwtjQuLXQogvhBDzmtsgRaMggE1SytGBL+AGjAmpTZwLj1yNkYGzIqSPDsCJkG3DMUbxa4DFQoiVwF+BK3x/rwA2CiEuj2DXGYwUyplADsYk8EsB+38CPOKLpQ4GdgK/xXgieAWTp4AIzMd44kjFiPErDC703/vzwB1CiK8w5pM+idSwTY3opZTPYaSsXbBIKac1tw1NQG0DEg1jonaFEGIwcAtwWUBeehKQgZFR82bNQb4shRHAFVLK/wvY7h/RRzhfHOfi8EeEEBdjTASWYzjkW339XIqRk3+TEGIAcBMwFPgH8LCU8le+doGjeivBoZsau7wYv9VZhE9I47NlWuRL1Da50H/vUsoi4NJo2rYpR69os1iBsUKIrSHbbYDNF3K5FiMMc7OU8ouANr/HcPLLOTdhC8Zo/m0pZWiKo93XbxhCiPkYIZjHfQuZXvC1nyulLBJCfB1Y4FuIdRYjpOD1TfT+TEpZIoT4AfCQL3VzB7A74BR/AV6VUlYLIbIxnhDAeBp5BuNJ4CcRrpFCEZE2tWBKcWEjhLCdzwUzQohBUso9IduyQhetCCGsvlTR0OMTpJSVTW2nQqEcvUKhULRx2tpkrEKhUChCUI5eoVAo2jgtZjK2Xbt2smfPns1thkKhUDQcKeE8rVbetGlTfl2lWFuMo+/ZsycbN9ZZ+rDFU15ezo4dO8jLyyMzM5Nhw4aRkpLS3GYpFIrzQPXKVRT/+te4Dx1G2O0k3H4bqb/6JcJmmsjVKAgh6lws1mIcfVugsLCQhQsX4vF48Hq9nDlzhn379jFnzhyyshql9rlCoWihOHfuouDr30BWGVmxsqqKildfw1tURMbfnmpW21SMvhFZvXo1LpcLr9fQnZJS4na7WbVqVTNbplAompqyp59GOhzBGx0Oqj74EE9hYfMY5UM5+kYkNzfXdPvZs2dRaawKRdvGvS/HiM2HIGw2PMePN4NF51COvhGxWMwjYRaLBa/XS2lpKY7QO75CoWgTWLOHg66HbZdOJ5ZmTjRRMfpGZPDgwWzfvt0fugHQNI1OnTrx+uuv43a78Xq9dO7cmenTpxMXF9eM1ioUisYk+b77cCz+GFl5brGziI8n4bZb0VJTm9EyNaJvVHr06BEWovF6vZw4cQKHw+F39KdOnWLpUnNp8dLSUrZv38727dspKyszbaNQKFoe1r59aDf/PWwTxkOcHa1DB5If+Ampv/ttc5umRvSNycaNG01j8WbOPz8/n+LiYtLS0vzbt2/fzoYNG/ztN2zYwPjx4xkyZEiT2q1QKBoH29ChZL37TnObEYYa0Tci+fn5UbfVdZ2KinNFh0pKStiwYYM/NdPr9eLxeFi7dq0a2SsUigahHH0EAtMkoyUpKSnqth6Ph8zMTP/7w4cPR3waOHLkSEx2KBQKRSAqdBPCyZMnWblyJaWlpWiaxoABA5gwYQK6yWx6KBdddBHLly/H7T4ncV5znNfr9Ttyi8XC0KFDo56MVamZCoWiIagRfQAFBQUsXbqUkpISpJR4PB727dvH559/HtXxPXv2ZMKECdjtdnRdR9d1Bg8ezE033cTAgQNJSkqiXbt2TJkyhTFjxoQdK0y0MYQQ9OrVq1E+n0KhuDBRI/oAtm7dGjQaByPEcvToUSorK0lISKizj0GDBjFgwAAcDoff4QNMmTKl1uPS0tIYNWoUmzdvDhr9p6am1hpCqq6uJicnh4KCArKysujXrx+2JtTVUCgUrY8mHdELIVKFEB8LIT4RQsz3VW1vsRQVFZlu13U9pglRTdNISEiIKtwTyMiRI+nTp0/QyL6wsJD58+dTXl4e1r6kpIQ333yT9evXk5OTw7p163jrrbfU5K1CoQiiqUM3twFPSikvA3Ixihu3WLKyskzDJx6Ph9TzsODB4XBw8ODBsBG82+1m27ZtYe1XrFhBdXU1Ho/H366qqorVq1c3ua0KhaL10KSOXkr5rJRyme9tFkbB5BbLyJEjw2QMLBYLAwcOrNcqViklZ86cYevWreTk5OByhZUNDaK4uNj0KaBGCTO079OnT5v2c+LEiZhtVSgUtVO1ZAlnpk7jZK8+nJl6MVUffxzVce4TJyj66c/InTyVvHk34/jqqya2NJzzEqMXQkwA0qWUa0O23w3cDdC9e/fzYUqtpKSkcPXVV7NmzRrOnDmD3W5n2LBhDBs2LOa+vF4vn3zyCadOncLtdiOEYMWKFVx11VV07NjR9JikpCT/6DwUsycKIYRpRo6mqTl2haIxqfzwI4p/+CO/OqX74CGKvv8D5FN/JWHO7IjHuY8d4+zlVyArKsDjwXP4MIWbNpP6yMMk3nLz+TK/6YuDCyEygE+A66WUEQXyR48eLdtC4ZEadu/ezZo1a8IctxCC2267LeLE7scff8ypU6eCjtM0jQkTJjBo0KAgJ758+XIOHToUpq0zcOBAJk+e3MifSKG4cMmdOAnP0WNh2/Xu3em4JrIMeeGP76fqvfch1A+kpNBp+1aE1dpg24QQm6SUo2tr06Qjet/k6zvAL2tz8m2RvXv3mo7OpZR8/vnnJCYmcvz4cWw2G8OGDWPQoEEIIZg5cyYrVqwIcuBCCNavX8+mTZu48soradeuHQCTJk2iqKiIkpISf/8ZGRmMGzfu/HxIheICwXPMXGa4Lvlh5+o1YU4eALcb97HjWPv0bgzz6qSpn/HvAkYBvxZCfCGEmNfE52sRlJeXBznfUE6ePMn+/fupqqqipKSEtWvXsnLlSgCsVivTp0/nqquu8sfrPR4PLpcLh8PB4sWL/TcAu93Oddddx5VXXsnEiRO56qqruPrqq7E2wihBoVCcQ+tkHm7VIoRh/fs7dDDdLt1uQFL80MPkTp7K2TlXU/XBh022OLKpJ2Ofk1KmSymn+V5vNeX5WgIej4eFCxfWOfEa+B/qdrvJyckJ0r7JyckxfSLweDycOnXK/14IQceOHRk4cCAdOnQwzRpSKBQNI+UnP0HExwdtE/HxpDxwf63HJX//3rDjsNuJmzqV/BvnUfGf/+I5fBjX5s0U3f8TSv/8l8Y2HVArYxudo0ePUl1dHfNxmqZRUFDgf+90OiO2dblcFBcX8+mnn/L666+zcOFCjh0Ljx8qFIpwXHv2UPijH3P2qtkUP/gQnlPm2WuBJN48j9SHH0LLygIh0Nq1I+WhB0m8ufYJ1fjLLiXll79AJCQgkpLAZiPukkuwDB6Et7gYAgaEsrKS8n89j6fQfD1PQ1ArYxuZEydOhK2urUEIQVxcHA6HI+wRTUpJcnKy/32vXr04fvx4WF9er5f4+Hjmz5/vf2qoqKjg008/ZeLEiQwcOLCRP5FC0XZwfLWCwm/ehXQ6wePBtWs3lW++RfvFH2HpXbvUSOKtt5Bwy82Gc7Zao356TrrrmyTedivuw4fRsrLQ27Uj79rrwGRAKGw2XDt3ok+tfSV9rKgRfSNzvJbJmdGjRwfF3mvQNI3MzEzS09P923r37k1WVlZQXr/FYmHs2LHs2LEjLDTkdrtZu3ZtRLkEr9fL7t27effdd/2raWt7alAo2hpSSop//gtkVdW5CVKXC1lRQcmjf4iqDyEEwmaLOUQq4uKwDhqE7kuk0Lt2BbM0aLcbvaN5XL8hKEffiDidTioDyoiFkp2dTUZGBpdddhmJiYnouo6maXTt2pVZs4IXDZ89exaPx4OUEqvVSufOnZk9ezbDhg0LWzxVg9frDYrzB/LFF1+wdu1aCgsL/VWs5s+fH/HpQ6FoKUivF/eRI3gCQpv16qekBI/ZIkOvl+o1axrUd6wkfftbCHuIIozFgqV/f6z9+zf6+VTophHRdT3iIqaEhAR/DnzXrl259dZbqaysxGq1homQ5ebmsnjxYr8T9ng8nD17lvz8fNq3b09iYqLpDUVKabqCt7i4mMOHDwdN7tbcFA4ePMiAAQMa9LkbTEU+FB2E9N6QmNW8tihaFI7PllP0kweQ5eVIjwfbmDFkPPsP/8g4JiwWiJDVoqWkNNBSg6pPllH+wot4i4qIn3U5Sd/+lmm9WNvw4aT99a8U/+KXxlOF241t1Egy/vXPRrEjFOXoGxFd1+nbty8HDx4McqoWiyVsda0QgsTERNN+1q9fHzbSdrvdbNiwgYEDBzJy5Mgw3XtN0+jTp49pauXZs2dNHzXdbjcnT55sPkfv9cCH34Xtr4JuB3c1DLsZ5jwPukoRvdBx5eRQeM93jFCLD+e6dRTcdgftl0YnP1CDt7iYvGuuNd0n4uNJuvvbOHfswL0vB0vfPlizs2MOz5Q++VfKn3sOWWnYW3boEJXvvkf7ZUvRAubfakiYM5v4K2bhPnQILSUFvY5UzYagQjeNzKRJk+jUqRO6rmOz2dB1nT59+sQko1BYWGi63e1243Q66dmzJ507dw7aJ6WMKCORkJBg+qXVNC1oAvi889WjsON1cDugugQ8Dtj5Nnz+YPPZpGgxlL/0b2PSNBC3G/ehgzh37oqpr5I/PYb76FEIDVUKQfx111L14UfkX3c9xb/6Ffk3ziNv7jV4Y1CB9RQWUfaPZ/xOHoDqarx5eVS89nrE44TFgrV//yZ18qAcfaNjtVq58sorufHGG7n00ku55ZZbuPjii2PSn4nkfIUQ2Gw28vLyOHnyZNC+mhW3ZhOsnTt3xm63hzl7TdMYNGiQuRHlZ+GTn8Gz2fDalXBoedT2R826v4MrJATlroQN/2j8cylaHZ5jx8xXleo63txcvEVFFP/6N5weMYrTo8dS+vgTfi2aUKoWfQBOk7UtmgZCw7l1K7KyCllRiaysxLVzJ8W/ezBqW13btyFM6kBIhwPH8ib47cSIcvRNREpKCl26dImqWEkoF110kamK5rBhw9A0jf3795suptI0zTSfXtM05syZQ7t27dB1HYvFQmJiIrNmzTKvc1t+Bp4bBuv+Bme3w4GP4X9zYOO/Yv4stVIdYfVwdVnEWKriwsE+aRLE2cO2S6cTy4D+nJ09l4rX38Cbl4f39GnKnvsn+Xfcab66tJYwTOX774enOjqdVM1fEPVKVa1dO/Obkqahd+ocvv08oxx9C6Rnz55MnjyZ+Ph4NE3DarUyfPhwRo82dIsipVBKKSPuS05O5tprr+Xmm2/m+uuv59Zbbw0L//hZ9ReoKgZPwNOBqxI+eQBc5iOmetE5gg5Tp5G1/jAVFwaJt9+GlpoGgfNO8fEk3norzvUb8OblBS04wuHAtXUbrs1bwvpKmDsHbCHzPrqObcKE4D4CcTrxRihGFIp1yBD0bt0gJHVa2O0k3fWNqPpoSpSjbwLOnDnDkiVLeO+991i9erVpdai66N+/P7fffjvz5s3jiiuu8IueAfTp0ydsxA+Go+/cuXOto5DExERSU1Nrn2g6sAS8Zjn2AvJ2x/pRInPF38GaCML34xA6WBPgiqcb7xyKVouWlkb7T5aQeMcd6N26YhkymLRHf0/qIw/j3LzZkP4NQXq9OHfsCNue8oufY+nZE5GYCJqGSExEa5dJ+hN/wR5pcZIQYZIE3tJSin76M07168/JXn0o+MZduE+eRAhBu9dfxTp0CMTFIZKSEMlJpD72J2zZ2Y1yPRpCk8sUR0tbkCmWUrJ8+XIOHjwYtN1ms3HNNdeQlpYWU1/r1q1j165daJqG1+ula9euzJgxA13XWbFiBQcOHMDtdvvj/zabjerqanRdZ8iQIYwZM6Z+2vSvXAaHloVvt8TBfTmQ2i32PqWEI1/AjjcAAcNvgx5TIX8frPwjnN4CHbNh8i+g/ZDY+1dcUJS9+BJlf/xTWExeJCWS8cwzxM2cEXaM9HhwfLYc1+7dWHr1JH7WLITdjisnh7OXhLcHEKmpdN690zheSvKuuBLXvhyomQvTNLTMTDqs/ArNFwZ1HzmCt6QE66BBpnH7xiYamWLl6BuRHTt2sCbCwosePXpw+eWXR93Xnj17WLNmTVAKZU0Gz7Rp05BScvbsWY4cOUJ1dXVY3F7Xdfr3719nUXJTDiyFt64LnijVrNBtInzji9j7A/joPtj6n3N9WhNg1Lfgiqfq15/igsZbVETuxEnI0oDMGF1H79iRDqtXIkyeeCMhHQ5O9e1vPi+UmkoXn6OvXruWgju/Hv4kkZBA6m9/Q9Idd9TnozSYaBy9Ct00Itu3b4+4L1LZv0hs27YtLJfe4/Fw8OBBHA4HFRUVZGVlMW7cOCoqKsImZz0eDzk5OfWTOeh7Ocz4g+GM7SnGSL7bRJj3Xux9AZzeClv/Da4KQBovVwVseh7OhD9mKxR1oaWnk/Xee1gGDzZi+FYrtrFjyFowPzYn7/VSvXoNmCUlANZ+/XCfPo3r6FGcu3YjzSZcKytx7WrEkGYToBZMNSKOCKldQNjq17qIpIDp8Xh4/XUjL1fXdcaOHUtxcbFpW03TKC8vJyMjI6pzFhUV+Wvb9ux5PV0e+BYibxckdYC0HjHZH8T+xeA2ueF43ca+DrGXalQorIMH0WHZUjyFRQiLHvPqVq/HQ+HXvoFz3TqIIF3i2riRM6PHGskBmmauT5MQjzVSmnILQTn6RqR9+/YRR+6x1p3t1KkTR44cMd1XM3r3eDysXbuWjIwMykwWd3i93qgXRO3atcsviialJCcnh+7duzNjxoyGa9xbE0CzgCdksYpmMSZjFYoGoGekm26XUuL4eAnlL72Et7SU+FmzDEmClBQqP1pM8U9/hqylQFBIZ0b6pMdjOPua7DZNQ4uLJ+E681W3LQUVumlEJkyYEHFf6Kja7XZTVlYWsRj42LFjsUYhhep2u3E4HKZ590OHDq2z2lRxcTHz589n1apVfhG1mn6PHTtWqxpn1Ay5KXK65OAbwrd5PcY8wYZ/wol1KqdeERHp8eCtqDDNNCv902MU/eCHONeuw717D2XPPMvZK67Esfxzo9B3tE4+FE0zwkWahn3KFLI++sBU4qAloUb0jUhaWhq6rps6782bN9OlSxeklGzcuJEdASlg2dnZjBo1Ksipp6WlccMNN7Bt2zbOnDlDYmIiJ06cMM2Tr66uZvbs2axZs4b8/Hzi4uLIzs5myJDas1ecTicLFy6MGCZyu90cPHgworRC1KR0hmtfhvlfB82XSik9cO2rkByy9LvsNPx7MlTkGaEdoUGXMXDbx2ANF2xTtE2cW7ZQ/sqreAsKib9iFgnXXoMIEOyTbjelf/4LFf/5L9LpRG/fnpSHHyLhCkMF1pOXR/kLLwYvhKquxnPmLEW/ezBIPydmPB467t6Jlpzcaiq6KUffiFRVVUX8j6+pIbt9+3Z27NgRNNG6bds2f5HwQJKTk5k8eTJghGFeffVVU6eclZVF+/btufrqq2OyN9IK20BCtfPrzZAboc/lcHApIKDPZRBnElOd/zUoPmrcCGo4sc7QxZnxSOPYomjRlL/6KqUPPYysdoLXi3P1aipeftmYaPU5+5IHH6Lyzbf8Dttz6hTF9/0A/ZWXsU+cgOOLL83j6VVVeANKcdYLKckdOhzb+PGkP/k4lq5dG9bfeUCFbhqR2uQO0tLSOHHiBFu2bDFVpty6dWutfWuaxvjx401DNGPHjg1rL6Vkz549vP3227z66qssX748LI5fXFxcqx69xWJpXGXLuBTD4Q+5wdzJV5fD4c+DnTyAu8rI2lG0ebzl5ZQ8+DCyyuGPg8uqKtwHDlLxzrtGm4oKKv73ZtioXFZVUfrkkxT9/BcU//RnYDZq13X09u3NbwKx4PHgXLuWvDlXR9TXaUkoR9+I6LrOiBEjwpyxpmmcOXOGZcuWRUx3rC1jp4YBAwYwY8YM2rVrR1xcHN26dWPu3Lm0M9HmXrt2LWvWrKG4uJiqqioOHjzI+++/H6RjH1rBKtTmESNG0CFCFfsm4dQGkBFuPJ7ai60r2gbOTZsQJvNKsqoKx4cfAeDNy0NEcNSunbuofO/9yLIGViupv/1NUBgIMLTqIyGEsT/0ad3jQVZUULVkSeRjWwgqdNPIjBw5ErvdztatW6mqqiI1NZWSkhI8Hk+tYZJoV8326NGDHj3CUx2dTidHjhzB4XCQmZnJ7t27g84npcTlcrFjxw7GjRsHGOUKN27cSEXAZJYQgqSkJGbPnh2esVMz4dVUccklP4qwQ8Cg65rmnIoWhZaUfC6jJXRfehpAZElfIQxZ4whzTiIlmbQ/P0b8FVdgWdCDkj/8kepNmxAWCzJCijIANpthk8mEr6ysxH34SC2fqGWgHH0jI4RgyJAh/onQlStXRsxzr0HX9VozdurizJkzLF68OEjUzCwLwev1ciogPmmxWOjVq1fQxDAY2UNBTj5/n1Eg5OiXoNtg2K0w6ymwN2KmQXV57To603/feOdStFisI0egpaXhqawMcqwiPp7Er91p/B0XR/IP7qPsb38PCt+IuDikppk7eouFDiu+8lemsg4ZTOYr/yXv6mtw7dxVe2ZXhBsHgEhIwDpkcIyf8vyjQjdNjMPhMHW6Qgh/LdirrrqKrvWc0PF6vXzyySe4XC7cbjder9efC292ztSAsma5ubns2bMnqE2NXo8/dl+RDy9OMHRqpNcoErL9dXj18oanPTpK4fPfwdMDjUybSP0ldYDEkPCUxwWbXoR/T4WXZ8CO/0UcCQZ8ONj+Brw0Gf45ElY8Bk7zGruK5kFoGplvvIbWsSMiKRGRnAR2O8n3/xh7wGAo6fv3kvrIw+g9eiASErCNG0e7d94ibsoU0/i73q0rWmZm0LbqL77EnbM/cpinLmxW9M6diZs+vX7Hn0fUiL6J6dGjB8eOHQub9NQ0jXnz5tVLrz6Q/Pz8qAt867rO8OHD/e9zcnJMjxVCcPz4cXr16gWbXzScOwFO2FMNZ7bDqU3QJUBiY+8iWPMklOeCLQnKThr/jv4OjPsh6AFfN5cDXhwPRYeM/sCnYqkBAQ7bEg+jvwuVhbD6L7BnPthTjQIlRYfOaeecWAf7P4brXol8AT78Lmx/zSfFgPGksvMN+PZ6sITrniuaB2vfvnRcvxbnhg14S0qwjR4TtihKCEHiLTeTeMvNQdtTf/MrqlevNiZInU7QdYTNRvpjj/nrOXtP5+IpK6Nq2TJTBcxa0TSEbwVuwtw5pPzi5zFJLjQXLd/CVk7v3r3ZtWsXhYWFfqdqsVjIzs6O2sl7vV7Wrl3L/v37kVLSo0cPOnbsyOnTp5FSRoz92+12XC4XQgji4uKYMmVK0MRtJO36oH25W42sl1CEgPy95xz9l7+HlX8650QDWf5bOL4G5r17btuut6Dk2DknD75sG2E4d91qjNr7XgFj7oXnLzJy7D0RHqNdFbDnPch9ADoOD99feAi2vey7aflwV0HhQdj1DmTfHvFaKM4/QtOw++aSYsHSqxcdPv+MshdfwrVhA5a+/Uj6zt1Y+/Wjet06Cr//A7ynTxtPd/WYa7IOG0r7xR/FfFxz0+SOXgjxEjAY+EhKecEFWnVdZ86cOeTk5HDw4EFsNhuDBw8OC9U4nU52797NoUOHsNlsDB06lB49eiCE4K233gpKjdy/fz/79++v9bwWi4Xx48fTq1cvXC6Xv26slJK8vDwcDgfdu3fn0KFDYaP6GklkADpdBPsWhTt76YUsX2yyqhhWPBrsRANxVxqaNnsXwc634MxWcFWZ3xSsCTDpZ4ZUcfth0K4/rHnKqHoVycn7DffAkc/NHf3xVSBMvu6uCkN/Xzn6NoPWoQPx06ahJSWhd+iA3rEj7hMnyL/tjuCUy7pCj7oeVDVKxMeT+tv/ayKrm5YmdfRCiOsAXUo5QQjxbyFEPyll7R6qBSOl5MSJE5SUlJCenk7nzp2jWhmn6zqDBg2KWJ/V7XazYMGCIEmEs2fPMnToUNq1a2eqY1MXSUlJ9OvXD03T/IJqpaWlfPTRR/6FXR6Ph/T0dEpKSvy69kIIJk2ahN3uC2WMugtWPWY4Wekb5etxRnWozqOM96c3g26P7OjBWOX69vWGM6aWH5jQoOt46HvZuW0HPzF/qghFt0JCeKopAIkdzEdwmhVSG7jyV9FikNXV5N92O67t241c/Lg4Sh5+hLgrr4gtFh8XR8LN83Dn5OA+eAjroIGkPPATbCNHNp3xTUhTj+inAW/7/v4EmAz4Hb0Q4m7gbqDhy+ybGIfDwaJFi/ySwLquk5KSwpw5c2JWpgwlJyeH8vLyoBCM2+1mx44ddOrUqV59tmvXLqjoiJSSxYsXmy6aGjNmDBUVFVitVvr16xc0YUtCBnx7HSy+Dw59ZsSys++ESx871yapI3jr+BHVtR8MJx+XBr1DikBE64iFDgOvMd/Xa7qRJeQsJ+hGo1sNXXxFm6D8vy/j3LIVatalVFYigaq33o45eSDl/h+jh0zgtlaa2tEnAid9fxcCowJ3SimfB54Ho/BIE9vSIFauXElpaak/du31eikqKmLt2rVMnTq1QX2bTdYC9asOhfEEkZ4ePHlVUFAQtFiqBo/HQ25uLpdddlnYPj8ZfeD2xZH3tx8M7QYaE7Te6CaGg7AmGvH5doMMzXstRHah90zYVEdh8oT2cNuHYIughqlb4OtfwP/mGnMDQjNSRa99FTJ6x26zokVS+fbb55x8IDE6eeuA/m3GyUPTO/pyIN73dxKtNJ1TSsmRI0fCJi+9Xi8HDhxosKNPTEz0x89D6dOnDydOnIipP03TwqQLnE5nxDBTNKty6+S2xUZVqtObDSfqdpwL9dRqrBVueMvQpHeWw96FRrGTQddCvO9mpelgSTBi/WboNpjyS0P8rDYy+8G9u6Egx8jWaT8sOBNIofDh2rET6fVGXIHb2mjqb/kmjHDNWiAb2NfE52syIpVcbIxSjIMHDyYnJycse8Zms7F69eqY+kpPT2fatGlhGT1ZWVmmttYsmmowSR3grlWGIFlVoTFR+8I4OLOt9uO8bnh3HvS7EnI+NG4OmgU+vg9uXgh9ZkKHbIJSLkPRrJFH8qEIAe0aUb9HcV6QHg8Vb7xBxX9fRlY5iJ99Fcn3fg8tMMwIWAcPwb23EdyMrjfdCvBmoKlvVwuAO4QQTwI3Aa0vLwkjZ9ds4lUIYSpHECuZmZlcfPHFWK1WrFYrFouF9PR04uPjccUwgaTrOmPGjCErKytsn9VqZcKECUHaNhaLheTkZAYOHNjgz+AnrQd0GmnE8kd8w0iVrBV5LjXSXWVM+roqjBH329cbC7aOrYSM/oZDN+3CCwOvNXLti4/WvXBK0eoo+vH9lD70CO69+/AcPUr5Cy9y9srZeAOyaKTHg+OTT2LrWNPCHbrVSvxVV7YaCeJoaPLi4EKIdOBS4CspZW6kdi29OHhZWRnz58/H7XbjdruxWCzYbDauvfZaEhMbp0qSx+OhoKAAq9VKWloaL7zwQsx9dOrUiTlz5iClZOvWrWzfvh2n00lGRgYTJ05E13V27txJVVUVPXv2ZMCAARGFzRqMywEvTTRy8WvLtImENREQIDBCQULzpbt5jIlXzWaIoF10N+TtMnL1hQ7xaTDnBeh/ZWN+GkUz4Tp4iLOXXhYuRSAExNmx9u1H8i9+jma3GSmUtUgWBB2elETCzfOoXrsWz6HDRqhG19G7diXrvXfQQua5WirRFAdv8gCllLKIc5k3rZbk5GRuueUWDhw4QFFREZmZmfTp06dRnaSu67Rv3x4wQkKRipgAEWP6Vb4Rztq1a9mzZ49/kregoICPP/6YuXPnMv18Ldm2xp1z1vVx9K5K8+M0i5Gm6fGN5jY8E7y/rBLeuRG+tQ46DI39vIoWhWvrVkN4LNSBSwlVDlw7dlB42+1YL7oIYbWGtzNBpKXRccM6tIQEpJQ4163DtS8Ha9++2CZOaFOjeWilk6PNhdVqZdCgQUycOLFpR8IYjrxv375hmTc1E61m59Y0je7du/sXX5np3m/atKnJbA6j+CicWE2t8XUwcvBNwzIRbg5ed+R9NbirYe1TdduoaPHoHToYY4U6cG3aFLFylNaxoyE1bLFgHTmCrEUL0XzzWEII7OPHk/S1O7FPmtjmnDwoCYRmQ0rJ6dOnKSoqIi0tzXQOYMKECZSUlJCfn+8fwXfo0IFJkybRqVMnVq5c6Xfmuq5jt9vJzs6mvLwcTdNMnwYKCwvPy+ej6Ag8P7r2zBt7qhGTH34HVJcak7GuSiO3veaXXddq2EhIDxQeqN+xihaFbeIEtIwMPFWOoJWqpoTuj4vD2r8fWQvm+0f6WopJ0Zs2Tqt29KdOnWLz5s2UlpbSrl07Ro8eHVaEuyVSXV3Nhx9+6M/L1zSNpKQk5syZQ1xAQQSbzcbcuXPJz8+nuLiYjIwM/+fr378/qampbN++nYqKCrp27crQoUOJi4tD1/WIOjbn7fp8fB84isz36TYY8XUY+U1I72MoU0oJx1dDzmKIS4WhN8O/p0DpsfqdX4+DntPqa72iBSE0jXbvvkPhPd/FtWuXIVYW1YGCpO/cQ8p930fY7Qj7hStc1+STsdES62TsoUOH+Pzzz4NGrRaLJWLFpZbEl19+yf79+4OcsaZp9OrVixkzZtRyZPSsXr2avXv3BoVvdF3n6quvPj/X5xE7eCL8IDP6G6tt49MiH39mB3z+W9i7IPZzaxaIz4Dv7QqXN64PZ3fBxz8wsn9sSXDRd+CSB31PHorziSc3l4Lvfg/X+g1RtbdOGE/7d98BoOqDDyn9+9N4z5zBetEoUn/xc6yNWSqzmYhmMrZVxuillKxevTosNOF2u1m3bl0zWRU9Bw8eNF18dfjw4UbJywcj7DNixAisAWXZpMfN7o//hWv3Qp/mTBMSKRVSs8J3t4c7eSkhby/kboeN/zJy8Pd9EMMJhRHrT+wI/efAvAWN4+SLjxl6/IeXGzeuqkJY+1d4/46G962IGa19e1x79kbd3rVuPc5Nmyl/4UWKfnw/7t278RYUUL3sU/LmzMVVhzhgW6FVOnqn0xlxNefZs2fPszWxEyms0phPV0II+vfvH3xeBPsrUlm6fAW8dgV4zOUKioqKWLduHStXruTEiRP1s2v47YbjDTJKN7Rs3rgS9gfU2Ty7G54eYEgRvzQRPvyOkVMfWiQcjBRLoUPmQEjrA/GZ0H4ozH4OrnrWWD176FN4ZQY8PwZKT4X3EQvr/hY+T+Cugn0LjZuA4rziPnQYEWX9BQC8Xgrvv5+SP/4xeKJWSmSVg9Innmx8I1sgrTJGb7Va0TTN1GE2tJBHKGVlZaxZs4YTJ06g6zoDBgxg9OjR9c64KSsrw2KxhBUJF0LQtWvXRp3xD60bC+DRbJyx9KDo1HzSd70Fw28L2r9nzx5Wr17tr1KVk5ND9+7dmTFjRmy2XfYXY1XsmR3GaL3GcVfmGaPjw8thwDVw45vw32lQmU+dmTRpPeGSR2DIjeGFQk5uMPpxBcgknN4Cr82C726r/yrHkxvMQ1C6HfL3QFrLFuNrS0iHA+emjcgYK0J5Dhw03+H14tq0uREsa/m0yhG9pmkMHDgQXQ8Wv7JYLIwYMaLRzuNwOJg/fz5Hjx7F7XZTXV3Nrl27WLp0ab3683q9LFq0KMzJgzHxOnny5IaaHERBQYHpzVDDQwnJRknAABwOhz8kVjOKd7vdHDt2jOPHj8d2cnsy3LUa7vwUBt9g7mj3LTCKkoRWsDJFQPcphm68WTWodX8Pl0mWHqMK1ZntsdkeSMds8zCUpxoy+4dvVzQJzk2bOT3yIkp++2DdmTcxoHfr1mh9tWRapaMHGD9+PP3790fXdSwWCxaLhZEjR4aFKxrC3r17cblcQaELj8fDmTNn6pWmePLkSVMnX1NQPKggdyOQlZWFpoU7WC8W0lynfYuZgu0zU8x0u90cOnQodgOEgG7jjZKCkdIsd7wRneKlNR4u+nbk/aUnzM+h6UbRkvoy/sfhNxZLHPS+DNIbQSNIUSfS6ST/jjuRpaXI8vLISpQWC8RFn1kj4uNJ/tEPGsnKlk2rDN2AMaqfMmUK48aNo6qqisTExEZfwJSfn2+aiy6EoLCwMOZUxYqKCtN4t5SSilhrV0bB4MGD2blzJ85qn3wAoHuddHHuIU2rCHOcoU9I0e6rE2ttEhG15NnrcYa6pMcNU34FPaYE73c5jAwb3WKUHDyxLrxAicdpFEmpLxm94Wufw0ffg1MbDSc/8i4jNKU4L1SvWhXdKN7tJv2fz1Lx/Is4N2yIfEOw29ESE0l58LfENVB5trXQah19DTabrcGFPyKRnp5uKkMgpQwuzhEl7du3j6ggWd8CI7WRkJDANddcw+rlH3MqrwiLdDKwai1jKj6Esd+DPpcGtQ8tbxhoX6jscUxM+inkLDLfN+gGYzS+9/2QHcIoaDL9EaMQSXLA9Tm5AT64xwjJaBYYdgtM/z1sfC64rqw10ShLmNDAtQNdRsPd641MJWEigqVoUmRVdDLaeq9eJFxxBXFTp3J64GBzR69pdFy9Ei0rC9GQwUsro9U7+qZk0KBBbN++PcjRa5pGenp6vXLRMzIy6NatGydOnPDnt2uaRmJiIr17N03xi7S0NK687hajRuv+xeBIhl5/gvSeYW0tFguXXXYZS5cu9a/ElVIycuRIvwZPvegxGYbcDLveDN4elw6Tfw5b/m3cCIJCOBKq8iG9d7CTLzoCL0/3VYrCGOnt+J9RTOSezYbswd4FRknBcT+EgXPrb7fHbdSadTuM+QFb4070K6LDPnFC3ROwcXGkPfg742+Px1ClNJmfEklJ6B07NoGVLZtWu2DqfFFYWMhXX31FXl4eQgh69+7N5MmT6/0U4fV62bFjB7t27cLj8dCvXz9GjRrVZE8l9cHlcvknoLt27UpSUlLjdLx7Pnz5EDiKjVz3Kb+ElM7w3m1GrD4UWxJc+QyMuPPctiX3w/p/hJcmtCbA3Rshy7wub8ycWA9vzPapZgrjJjT3JRh2c+P0r4iJ8ldfpfShh5FOl+HI7XZEfDxC17H07UPKAw9gnzjB3/7srCtx7dgR3InFQsK8m0j/82O0JVqEemVrJyMjg2uuuQaPx4MQot7l/Wo4deoUW7du9acvHj58mP79+7cc6Yay01i/eJi++z80ct7H/dAoEN4Y4YrB1xovMEbmNROxqT0MRx2YGgnG5GqH4cHbzu40rz+rWQ1tm8Zw9K4qeO1y44YUyMJvQueLjEpVivNK0h13YL9oNBVvvom3tJT4K68gbsaMiOGX9L8+Qd611xtPAg4HIiEBLSODlJ//7Dxb3jJQjj5KGjQZ6aO8vJxPPvkkSJagrKyMDz/8kNtuu61RztEgKgvgnyOhqsBwwKUnYMkPjXz4K59uvPNsfB6W/MhIf5ReEBYjO0bo5xZJWeKg20ToNCL42C7j4OhX4YuYPNXGwqnGYP9i85XDXhds+Q/M/EPjnEcRE9bBg0h7+KHo2g4aRIfVq6h8523chw5jGzWShLlzEfF1FcJpm7Ta9MrWSE5Ojmleu8fj4dixFrDKcuM/obokOFbuqoRNLxiTnI1B6Snj5uGuMjJivG7wOAzH2nsm2JLPxddvMZFAGHuvMfoXAV9dS7wRCmqsdEdHiXmqptdtSCAoWgV6RjrJ99xD+mN/InHevAvWyYMa0Z9XKioqTB291+v1FwxpVg4vD190BEYe+ektwZOi9aG6zBAHc5usNPW6jDTIO5aE7wskuSN8ez188hM49JlRK/aiu2HIPKPsYLT6Nrnb4LNfGymTaT3g4t9C/6uMfb2mm8sv2JKg/+zo+lcoWhBqRH8e6dq1a8Rc/6ZIr4yZjL5G+CQUrxtSu0HJcUPSIIJGTq04Soyw0L5FmObOmznWSGT2hVsWwq/L4bLHjcnZFyfAk13hjTlQfha2vQrv3gpLH4D8nODjT2+FlyYZIZqKM3ByPbxzE2z5r7E/vSeMvS84/9+aCF0nGEXMFYpWhhrRn0d69OhBRkYGBQUF/pRNi8VC7969SW8J9SnH/RC2vxY8KapZjaX+H9wDuVuMvHXNCnOehyE3RN/3+n8YK2TNJlJryIhxkvPIV4YAWqC9Bz+Bv/c1Qi+uCsPeDc/CDf+DgVcbbT79hbEvEFclLPspZN9hzBdc9mcjlLT5BWPfsFuNp4YGTsYrFM2BcvTnEU3TmD17Nnv27OHAgQPous6gQYPo27dvc5tm0H4w3PQeLLoLqooMZ9lzGpQehzM7jULcNSz4mvEEEDpZGom9C8zDQn40Q/AsFlb9OTxTx+MMFiHzuo3Xgq/DT88aGvKnIqTxOsuhIs8IDwH0vcx4KRStHOXozzMWi4Vhw4YxbNiw5jbFnH6z4P4TxgIkW7Lx778nBzt5MJz2ur/DNf+Ort+EOmLntkRI7hybradiqH8rvXB6M3TIjlwQBWGklCoUbQz1HKoIRwhjgjIhA8pPG+GPUKQXSo5G3+e4H9aieSOM8oKDro2+PynD89xrw+sxzr/sp+ZPFsICo74F1rjwfYpGR7rdjVp/QVE7ytEraqfzaPMC3ZZ46Dsrtr7svqLMQsMo/u2rCpU1GL7xlaFQGS0eV2yFw91VRjx/0wsRFlzpcPkT0fenqBfOTZs5e9nlnOrZm1N9+1P8m/9DRigipGg8miR0I4RIBd4EdKACmCeljLKir6JFkZhlSPWu+/u5CUzdbmy/6O7o+ti7EN695ZyypPQafcz6O/S73Hh6iBWLDVK6GvMHocS3A1c5IILPeXxV5P6kV9WAbWJcBw+Rf/PNyErf/4nDQcX/3sSTe4bMF59vXuPaOE01or8NeFJKeRmQC8Q49FO0KGY8Ctf8x1ip2m4gjP+RISAWF6WC5ycPmMgHV8Oax+vn5Gu49M/G4qlALAlw/evw/b3nniCiIVQCWdHolD//PLI6ZLzncOBYvhz3yZPNY9QFQpOM6KWUzwa8zQJafiHXVkphYSFbt26luLiYrKwssrOzSUlJweVycerUKTRNo3Pnzg2TVxDCKN835MZ6GhmhlFtRhO3RMuxmw9Ev/w0UHzZuQjP/ZMgae71GjnwkNKsRwtFthtzCrL81zBZFnbh27zbVlRd2G57DR7B06dIMVl0YNIqjF0L8CwgULF8upXxYCDEBSJdSrm2M8yiCOXXqFEuWLPGX/isoKODAgQOMHDmSzZs3+2u8CiG47LLL6Nw5xqyWxiKpA5TnmmxvBLnYgXPNpYg1zcj0qcwP35fYwdCwz91qzEGM+yGkmmvxKxoPW3Y2rh07IURyWFY7sfTt00xWXRg0SuhGSnmPlHJawOthIUQG8DTwzUjHCSHuFkJsFEJszMuLMYdawcqVK3EHZC9IKXG5XKxfvx63243L5cLlcuF0Olm6dKlpGcPzwsW/DQ+xWBNg6v817Xkn/dz8vNN+B7P+Cl//3KgUpZz8eSHpnrsR9hA57rg44ufMviA14s8nTRKjF0LYgHeAX0opI+bgSSmfl1KOllKOzsrKagpT2ixut5uSkpKYjjl6NIZ0yMZk9Hdg+qNGoRHdZvw7/VEYfU/TnnfiTwxnb0sysoRsycZNZ/R3mva8ClMs3bqRtXABtkmTwGZDy8wg+d7vkf7E481tWpunSQqPCCG+C/wB2Obb9JyU8q3ajmmphUdaKl6vl//85z+mNW3N0HWdCRMmMHjw4Ca2rBa8XqguNSZJz6eUgNtpSC8ntFOZNYo2R7MVHpFSPgc81xR9Kww0TWPAgAHs27cvyNnruu4vahJKpJqw5w1Ng/i0839ei63hypsKRStGLZhqxYwfP54ePXqg6zo2mw1d1+nfvz/du3cPUsm0WCwMGTKElJQY0g0VCkWbQWndtGIsFgszZ86koqKCsrIy0tLSiIuLQ0rJkSNH/MJpAwYMoItKXVMoLliUo28DJCYmkph4TkdGCEGvXr3o1auRKi61VNzVsP9jQ3it/2zI6N3cFikULRLl6BWtkyNfwquXn9O7WfJD6DwGvv4F2BJqPVShuNBQMXpF66O6DF6bFS5qdmoDvHtz89ikULRglKNXtD72fRBZU37/YnCUnl97FIoWjnL0itaHs8xQmzRDCKgqPL/2KBQtHOXoFa2P3pf6NO1NsCYYhcwVCoUf5egVrY+M3jDq2+HbhQ5X/sMoIqJQKPwoR69oncz5J1z3BqT3MbRsOmTDHZ9A9h3NbZlC0eJQ6ZWK1svwW4yXQqGolSYRNasPQog84CjQDjAREW8xKPsahrKvYSj7GkZbtK+HlLJW+d8W4+hrEEJsrEuJrTlR9jUMZV/DUPY1jAvVPhWjVygUijaOcvQKhULRxmmJjv755jagDpR9DUPZ1zCUfQ3jgrSvxcXoFQqFQtG4tMQRvUKhUCgaEZVHHwFf3dt5vrdpwDopZVg1ayGEBTjkewHcJ6XccV6MbMEIIVKBNwEdqADmSSnDlMjU9QsnmmunrltkovntXnDXT0p53l9AB2BFyLaXgDXAb+o4Nqp2jWzv08DoCPtGAY81wzW0AMeAL3yvYS3smn0PuNT393PA3BZ2/eq8Js1x3aK9ds113Xznjuq711zXL8QG099uM37vgnzf+fJ75z10I4RIB14GEgO2XQfoUsoJQG8hRL8Ix0bVrpHt7QJ0kFJujNBkPDBbCLFeCPGSb6RwPhgO/E9KOc33Mh2NNMc1A5BSPiulXOZ7mwWcjdD0vF+/aK5Jc103iPraNdf3DqL47jXn9QuwobbfbnN874J83/n0e80Ro/dgPFYFioZPA972/f0JMDnCsdG2ixkhxL+EEF8EvH7r23UvxqgqEhuAmVLKsYAVuLKxbKqDaL+o02iiaxZIpOsnhJgApEsp10Y4tDmu3zTqvibRtGlS6rh2zfW9g+i+e9No5utH7b/d5rh+ob5vGufJ752Pu9i/gAEBm5ZLKR8WQgQ2SwRO+v4uxHisMiPadjEjzePvGnAJ8OtaDt0upawpdbQRaJKRi8l1/Bzji3paCPEKxhd1kcmhTXbNAolw/TIwHp2vr+XQ83L9QojmmpyX6xaJKK5dc1y3GmqcZG3fvea+fnX9ds/79ZNSlvpsq9l03vxek4/opZT3BDziTZNSPmzSrByI9/2dVItd0bZrLKZgTOTUloP6qhAiWwihA9cA25rCkNDrCPxJSnnat7u2L+r5vmYACCFswDvAL6WUR2tpel6uXwjRXJNmuW4Q9bVrjutWw/YovnvNdv181PXbbc7rV8N583stJb1yE+ceR7KBIw1s11hcDnxV80YIMVgI8fuQNg8DrwJbgTVSyk+b2KYaov2inu9rVsNdGCOPX/tCOfNa0PWL5po013WD8Gv3uxZy3WqI5rvXnNcPAn67Leh7F8r583vne9Y5YBb5i4C/UzC+LE8Ce4BUYDDw+5Bjwto1l/3N/QKGAtuBHcCjvm3qmkV37UKvSba6bjFdv6DvnvrexXz9voh0jZrqWraYlbG+GelLga+klLkNbac4h7pm4URzTdR1axjq+tXN+fJ7LcbRKxQKhaJpaCkxeoVCoVA0EcrRKxQKRRtHOXqFQqFo4yhHr1AoFG0c5egVCoWijfP/9hc+NBFB1jIAAAAASUVORK5CYII=\n"
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "draw_iris()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 人脸识别 -40分类"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "outputs": [],
   "execution_count": 1
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "预测正确，图片为第23类\n",
      "预测错误，预测为第8类,因为是第4类\n",
      "预测正确，图片为第30类\n",
      "预测正确，图片为第15类\n",
      "预测正确，图片为第34类\n",
      "预测正确，图片为第30类\n",
      "预测正确，图片为第5类\n",
      "预测错误，预测为第22类,因为是第28类\n",
      "预测正确，图片为第37类\n",
      "预测正确，图片为第9类\n",
      "预测正确，图片为第17类\n",
      "预测错误，预测为第26类,因为是第21类\n",
      "预测正确，图片为第21类\n",
      "预测错误，预测为第34类,因为是第3类\n",
      "预测错误，预测为第22类,因为是第18类\n",
      "预测正确，图片为第34类\n",
      "预测错误，预测为第3类,因为是第19类\n",
      "预测正确，图片为第16类\n",
      "预测正确，图片为第4类\n",
      "预测正确，图片为第0类\n",
      "预测错误，预测为第11类,因为是第19类\n",
      "预测错误，预测为第17类,因为是第28类\n",
      "预测正确，图片为第7类\n",
      "预测正确，图片为第17类\n",
      "预测错误，预测为第39类,因为是第1类\n",
      "预测正确，图片为第4类\n",
      "预测正确，图片为第1类\n",
      "预测错误，预测为第15类,因为是第23类\n",
      "预测错误，预测为第12类,因为是第24类\n",
      "预测正确，图片为第32类\n",
      "预测正确，图片为第17类\n",
      "预测错误，预测为第7类,因为是第10类\n",
      "预测错误，预测为第7类,因为是第28类\n",
      "预测正确，图片为第19类\n",
      "预测正确，图片为第34类\n",
      "预测正确，图片为第26类\n",
      "预测错误，预测为第31类,因为是第33类\n",
      "预测正确，图片为第33类\n",
      "预测正确，图片为第7类\n",
      "预测错误，预测为第31类,因为是第29类\n",
      "预测正确，图片为第23类\n",
      "预测错误，预测为第20类,因为是第29类\n",
      "预测正确，图片为第26类\n",
      "预测正确，图片为第15类\n",
      "预测错误，预测为第34类,因为是第25类\n",
      "预测正确，图片为第3类\n",
      "预测正确，图片为第35类\n",
      "预测错误，预测为第1类,因为是第24类\n",
      "预测错误，预测为第31类,因为是第39类\n",
      "预测错误，预测为第12类,因为是第24类\n",
      "预测正确，图片为第2类\n",
      "预测正确，图片为第10类\n",
      "预测正确，图片为第27类\n",
      "预测正确，图片为第23类\n",
      "预测错误，预测为第22类,因为是第28类\n",
      "预测正确，图片为第2类\n",
      "预测正确，图片为第1类\n",
      "预测正确，图片为第30类\n",
      "预测错误，预测为第20类,因为是第19类\n",
      "预测正确，图片为第8类\n",
      "预测错误，预测为第34类,因为是第3类\n",
      "预测错误，预测为第11类,因为是第2类\n",
      "预测正确，图片为第5类\n",
      "预测错误，预测为第31类,因为是第22类\n",
      "预测错误，预测为第31类,因为是第39类\n",
      "预测正确，图片为第27类\n",
      "预测错误，预测为第14类,因为是第12类\n",
      "预测错误，预测为第26类,因为是第21类\n",
      "预测正确，图片为第10类\n",
      "预测错误，预测为第33类,因为是第15类\n",
      "预测正确，图片为第7类\n",
      "预测正确，图片为第26类\n",
      "预测正确，图片为第23类\n",
      "预测错误，预测为第19类,因为是第5类\n",
      "预测错误，预测为第12类,因为是第24类\n",
      "预测错误，预测为第22类,因为是第17类\n",
      "预测错误，预测为第30类,因为是第20类\n",
      "预测正确，图片为第32类\n",
      "预测正确，图片为第11类\n",
      "预测错误，预测为第31类,因为是第32类\n",
      "准确率为57.49999999999999%--[46/80]\n"
     ]
    }
   ],
   "source": [
    "face_recognition()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "outputs": [],
   "source": [],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}